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

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> {
@@ -35,8 +55,9 @@ export class TelemetryManager extends BaseManager {
 	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;
@@ -55,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
@@ -67,7 +89,7 @@ export class TelemetryManager extends BaseManager {
 			userId?: string;
 			anonymousId?: string;
 			properties?: Record<string, unknown>;
-			context?: {
+			context?: Partial<TelemetryManagerContext> & {
 				groupId?: {
 					Repository?: string;
 				};
@@ -75,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) {
@@ -117,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) {
@@ -143,6 +169,44 @@ 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 {

package/src/managers/telemetry/types.ts

@@ -21,8 +21,6 @@ export const SegmentEventType = {
 	customType_sliceZoneUpdated: "custom-type:slice-zone-updated",
 	customType_saved: "custom-type:saved",
 	slice_created: "slice:created",
-	identifyUser: "identify-user",
-	groupLibraries: "group-libraries",
 	screenshotTaken: "screenshot-taken",
 	changes_pushed: "changes:pushed",
 	changes_limitReach: "changes:limit-reach",
@@ -59,8 +57,6 @@ export const HumanSegmentEventType = {
 		"SliceMachine Slicezone Updated",
 	[SegmentEventType.customType_saved]: "SliceMachine Custom Type Saved",
 	[SegmentEventType.slice_created]: "SliceMachine Slice Created",
-	[SegmentEventType.identifyUser]: "IdentifyUser",
-	[SegmentEventType.groupLibraries]: "GroupLibraries",
 	[SegmentEventType.screenshotTaken]: "SliceMachine Screenshot Taken",
 	[SegmentEventType.changes_pushed]: "SliceMachine Changes Pushed",
 	[SegmentEventType.changes_limitReach]: "SliceMachine Changes Limit Reach",
@@ -98,7 +94,7 @@ type CommandInitEndSegmentEvent = SegmentEvent<
 
 type ReviewSegmentEvent = SegmentEvent<
 	typeof SegmentEventType.review,
-	{ framework: string; rating: number; comment: string }
+	{ rating: number; comment: string }
 >;
 
 type OnboardingStartSegmentEvent = SegmentEvent<
@@ -127,18 +123,15 @@ type OnboardingContinueScreen3SegmentEvent = SegmentEvent<
 >;
 
 type SliceSimulatorSetupSegmentEvent = SegmentEvent<
-	typeof SegmentEventType.sliceSimulator_setup,
-	{ framework: string; version: string }
+	typeof SegmentEventType.sliceSimulator_setup
 >;
 
 type SliceSimulatorOpenSegmentEvent = SegmentEvent<
-	typeof SegmentEventType.sliceSimulator_open,
-	{ framework: string; version: string }
+	typeof SegmentEventType.sliceSimulator_open
 >;
 
 type SliceSimulatorIsNotRunningSegmentEvent = SegmentEvent<
-	typeof SegmentEventType.sliceSimulator_isNotRunning,
-	{ framework: string }
+	typeof SegmentEventType.sliceSimulator_isNotRunning
 >;
 
 type PageViewSegmentEvent = SegmentEvent<
@@ -149,14 +142,13 @@ type PageViewSegmentEvent = SegmentEvent<
 		search: string;
 		title: string;
 		referrer: string;
-		framework: string;
-		slicemachineVersion: string;
+		adapter: string;
 	}
 >;
 
 type OpenVideoTutorialsSegmentEvent = SegmentEvent<
 	typeof SegmentEventType.openVideoTutorials,
-	{ framework: string; slicemachineVersion: string; video: string }
+	{ video: string }
 >;
 
 type CustomTypeCreatedSegmentEvent = SegmentEvent<
@@ -189,22 +181,6 @@ type SliceCreatedSegmentEvent = SegmentEvent<
 	{ id: string; name: string; library: string }
 >;
 
-type IdentifyUserSegmentEvent = SegmentEvent<
-	typeof SegmentEventType.identifyUser
->;
-
-type GroupLibrariesSegmentEvent = SegmentEvent<
-	typeof SegmentEventType.groupLibraries,
-	{
-		repoName: string;
-		manualLibsCount: number;
-		downloadedLibsCount: number;
-		npmLibsCount: number;
-		downloadedLibs: Array<string>;
-		slicemachineVersion: string;
-	}
->;
-
 type ScreenshotTakenSegmentEvent = SegmentEvent<
 	typeof SegmentEventType.screenshotTaken,
 	{
@@ -260,8 +236,6 @@ export type SegmentEvents =
 	| CustomTypeSliceZoneUpdatedSegmentEvent
 	| CustomTypeSavedSegmentEvent
 	| SliceCreatedSegmentEvent
-	| IdentifyUserSegmentEvent
-	| GroupLibrariesSegmentEvent
 	| ScreenshotTakenSegmentEvent
 	| ChangesPushedSegmentEvent
 	| ChangesLimitReachSegmentEvent

package/src/types.ts

@@ -36,8 +36,6 @@ export type SliceMachineConfigPluginRegistration<
  * Slice Machine configuration from `slicemachine.config.js`.
  */
 export type SliceMachineConfig = {
-	// TODO: Is `_latest` necessary? Can we deprecate it?
-	_latest: string;
 	// TODO: Can we make `apiEndpoint` optional?
 	apiEndpoint?: string;
 	// NOTE: This is a new property.