@hammadj/better-auth-telemetry 1.5.0-beta.9

package/src/telemetry.test.ts

@@ -0,0 +1,350 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { createTelemetry } from "./index";
+import type { TelemetryEvent } from "./types";
+
+vi.mock("@better-fetch/fetch", () => ({
+	betterFetch: vi.fn(async () => ({ status: 200 })),
+}));
+
+vi.mock("./project-id", () => ({
+	getProjectId: vi.fn(async () => "anon-123"),
+}));
+
+vi.mock("./detectors/detect-runtime", () => ({
+	detectRuntime: vi.fn(() => ({ name: "node", version: "test" })),
+	detectEnvironment: vi.fn(() => "test"),
+}));
+
+vi.mock("./detectors/detect-database", () => ({
+	detectDatabase: vi.fn(async () => ({ name: "postgresql", version: "1.0.0" })),
+}));
+
+vi.mock("./detectors/detect-framework", () => ({
+	detectFramework: vi.fn(async () => ({ name: "next", version: "15.0.0" })),
+}));
+
+vi.mock("./detectors/detect-system-info", () => ({
+	detectSystemInfo: vi.fn(() => ({
+		systemPlatform: "darwin",
+		systemRelease: "24.6.0",
+		systemArchitecture: "arm64",
+		cpuCount: 8,
+		cpuModel: "Apple M3",
+		cpuSpeed: 3200,
+		memory: 16 * 1024 * 1024 * 1024,
+		isDocker: false,
+		isTTY: true,
+		isWSL: false,
+		isCI: false,
+	})),
+	isCI: vi.fn(() => false),
+}));
+
+vi.mock("./detectors/detect-project-info", () => ({
+	detectPackageManager: vi.fn(() => ({ name: "pnpm", version: "9.0.0" })),
+}));
+
+beforeEach(() => {
+	vi.resetModules();
+	vi.clearAllMocks();
+	process.env.BETTER_AUTH_TELEMETRY = "";
+	process.env.BETTER_AUTH_TELEMETRY_DEBUG = "";
+});
+
+describe("telemetry", () => {
+	it("publishes events when enabled", async () => {
+		let event: TelemetryEvent | undefined;
+		const track = vi.fn().mockImplementation(async (e) => {
+			event = e;
+		});
+		await createTelemetry(
+			{
+				baseURL: "http://localhost.com", //this shouldn't be tracked
+				appName: "test", //this shouldn't be tracked
+				advanced: {
+					cookiePrefix: "test", //this shouldn't be tracked - should set to true
+					crossSubDomainCookies: {
+						domain: ".test.com", //this shouldn't be tracked - should set to true
+						enabled: true,
+					},
+				},
+				telemetry: { enabled: true },
+			},
+			{ customTrack: track, skipTestCheck: true },
+		);
+		expect(event).toMatchObject({
+			type: "init",
+			payload: {
+				config: {
+					emailVerification: {
+						sendVerificationEmail: false,
+						sendOnSignUp: false,
+						sendOnSignIn: false,
+						autoSignInAfterVerification: false,
+						expiresIn: undefined,
+						onEmailVerification: false,
+						afterEmailVerification: false,
+					},
+					emailAndPassword: {
+						enabled: false,
+						disableSignUp: false,
+						requireEmailVerification: false,
+						maxPasswordLength: undefined,
+						minPasswordLength: undefined,
+						sendResetPassword: false,
+						resetPasswordTokenExpiresIn: undefined,
+						onPasswordReset: false,
+						password: { hash: false, verify: false },
+						autoSignIn: false,
+						revokeSessionsOnPasswordReset: false,
+					},
+					socialProviders: [],
+					plugins: undefined,
+					user: {
+						modelName: undefined,
+						fields: undefined,
+						additionalFields: undefined,
+						changeEmail: {
+							enabled: undefined,
+							sendChangeEmailVerification: false,
+						},
+					},
+					verification: {
+						modelName: undefined,
+						disableCleanup: undefined,
+						fields: undefined,
+					},
+					session: {
+						modelName: undefined,
+						additionalFields: undefined,
+						cookieCache: { enabled: undefined, maxAge: undefined },
+						disableSessionRefresh: undefined,
+						expiresIn: undefined,
+						fields: undefined,
+						freshAge: undefined,
+						preserveSessionInDatabase: undefined,
+						storeSessionInDatabase: undefined,
+						updateAge: undefined,
+					},
+					account: {
+						modelName: undefined,
+						fields: undefined,
+						encryptOAuthTokens: undefined,
+						updateAccountOnSignIn: undefined,
+						accountLinking: {
+							enabled: undefined,
+							trustedProviders: undefined,
+							updateUserInfoOnLink: undefined,
+							allowUnlinkingAll: undefined,
+						},
+					},
+					hooks: { after: false, before: false },
+					secondaryStorage: false,
+					advanced: {
+						cookiePrefix: true,
+						cookies: false,
+						crossSubDomainCookies: {
+							domain: true,
+							enabled: true,
+							additionalCookies: undefined,
+						},
+						database: {
+							useNumberId: false,
+							generateId: undefined,
+							defaultFindManyLimit: undefined,
+						},
+						useSecureCookies: undefined,
+						ipAddress: {
+							disableIpTracking: undefined,
+							ipAddressHeaders: undefined,
+						},
+						disableCSRFCheck: undefined,
+						cookieAttributes: {
+							expires: undefined,
+							secure: undefined,
+							sameSite: undefined,
+							domain: false,
+							path: undefined,
+							httpOnly: undefined,
+						},
+					},
+					trustedOrigins: undefined,
+					rateLimit: {
+						storage: undefined,
+						modelName: undefined,
+						window: undefined,
+						customStorage: false,
+						enabled: undefined,
+						max: undefined,
+					},
+					onAPIError: {
+						errorURL: undefined,
+						onError: false,
+						throw: undefined,
+					},
+					logger: { disabled: undefined, level: undefined, log: false },
+					databaseHooks: {
+						user: {
+							create: {
+								after: false,
+								before: false,
+							},
+							update: {
+								after: false,
+								before: false,
+							},
+						},
+						session: {
+							create: {
+								after: false,
+								before: false,
+							},
+							update: {
+								after: false,
+								before: false,
+							},
+						},
+						account: {
+							create: {
+								after: false,
+								before: false,
+							},
+							update: {
+								after: false,
+								before: false,
+							},
+						},
+						verification: {
+							create: {
+								after: false,
+								before: false,
+							},
+							update: {
+								after: false,
+								before: false,
+							},
+						},
+					},
+				},
+				runtime: { name: "node", version: "test" },
+				database: { name: "postgresql", version: "1.0.0" },
+				framework: { name: "next", version: "15.0.0" },
+				environment: "test",
+				systemInfo: {
+					systemPlatform: "darwin",
+					systemRelease: "24.6.0",
+					systemArchitecture: "arm64",
+					cpuCount: 8,
+					cpuModel: "Apple M3",
+					cpuSpeed: 3200,
+					memory: 17179869184,
+					isDocker: false,
+					isTTY: true,
+					isWSL: false,
+					isCI: false,
+				},
+				packageManager: { name: "pnpm", version: "9.0.0" },
+			},
+			anonymousId: "anon-123",
+		});
+	});
+
+	it("does not publish when disabled via env", async () => {
+		process.env.BETTER_AUTH_TELEMETRY = "false";
+		let event: TelemetryEvent | undefined;
+		const track = vi.fn().mockImplementation(async (e) => {
+			event = e;
+		});
+		await createTelemetry(
+			{
+				baseURL: "http://localhost",
+			},
+			{ customTrack: track, skipTestCheck: true },
+		);
+		expect(event).toBeUndefined();
+		expect(track).not.toBeCalled();
+	});
+
+	it("does not publish when disabled via option", async () => {
+		let event: TelemetryEvent | undefined;
+		const track = vi.fn().mockImplementation(async (e) => {
+			event = e;
+		});
+		await createTelemetry(
+			{
+				baseURL: "http://localhost",
+				telemetry: { enabled: false },
+			},
+			{ customTrack: track, skipTestCheck: true },
+		);
+		expect(event).toBeUndefined();
+		expect(track).not.toBeCalled();
+	});
+
+	it("shouldn't fail cause track isn't being reached", async () => {
+		await expect(
+			createTelemetry(
+				{
+					baseURL: "http://localhost",
+					telemetry: { enabled: true },
+				},
+				{
+					customTrack() {
+						throw new Error("test");
+					},
+					skipTestCheck: true,
+				},
+			),
+		).resolves.not.throw(Error);
+	});
+
+	it("initializes without Node built-ins in edge-like env (no process.cwd)", async () => {
+		const originalProcess = globalThis.process;
+		try {
+			// Simulate an edge runtime where process exists minimally but has no cwd
+			// so utils/package-json won't try to import fs/path
+			(globalThis as any).process = { env: {} } as any;
+			const track = vi.fn();
+			await expect(
+				createTelemetry(
+					{ baseURL: "https://example.com", telemetry: { enabled: true } },
+					{ customTrack: track, skipTestCheck: true },
+				),
+			).resolves.not.toThrow();
+			// Should still attempt to publish init event
+			expect(track).toHaveBeenCalled();
+		} finally {
+			// restore
+			(globalThis as any).process = originalProcess as any;
+		}
+	});
+
+	it("returns noop publisher when BETTER_AUTH_TELEMETRY_ENDPOINT is undefined", async () => {
+		// Import betterFetch mock to check it's not called
+		const { betterFetch } = await import("@better-fetch/fetch");
+
+		// Clear any previous calls to the mock
+		vi.mocked(betterFetch).mockClear();
+
+		// Ensure the environment variable is not set
+		vi.stubEnv("BETTER_AUTH_TELEMETRY_ENDPOINT", undefined);
+
+		// Create telemetry without customTrack to test actual endpoint logic
+		const telemetry = await createTelemetry(
+			{
+				baseURL: "http://localhost",
+				telemetry: { enabled: true },
+			},
+			{ skipTestCheck: true },
+		);
+
+		// The publish function should be a noop and not make any HTTP requests
+		await telemetry.publish({
+			type: "test-event",
+			payload: { test: "data" },
+		} as any);
+
+		// Verify that betterFetch was never called since endpoint is undefined
+		expect(betterFetch).not.toHaveBeenCalled();
+	});
+});

package/src/types.ts

@@ -0,0 +1,16 @@
+export interface DetectionInfo {
+	name: string;
+	version: string | null;
+}
+export interface TelemetryEvent {
+	type: string;
+	anonymousId?: string | undefined;
+	payload: Record<string, any>;
+}
+
+export interface TelemetryContext {
+	customTrack?: ((event: TelemetryEvent) => Promise<void>) | undefined;
+	database?: string | undefined;
+	adapter?: string | undefined;
+	skipTestCheck?: boolean | undefined;
+}

package/src/utils/hash.ts

@@ -0,0 +1,9 @@
+import { base64 } from "@better-auth/utils/base64";
+import { createHash } from "@better-auth/utils/hash";
+
+export async function hashToBase64(
+	data: string | ArrayBuffer,
+): Promise<string> {
+	const buffer = await createHash("SHA-256").digest(data);
+	return base64.encode(buffer);
+}

package/src/utils/id.ts

@@ -0,0 +1,5 @@
+import { createRandomStringGenerator } from "@better-auth/utils/random";
+
+export const generateId = (size: number) => {
+	return createRandomStringGenerator("a-z", "A-Z", "0-9")(size || 32);
+};

package/src/utils/import-util.ts

@@ -0,0 +1,3 @@
+export const importRuntime = <T>(m: string): Promise<T> => {
+	return (Function("mm", "return import(mm)") as any)(m);
+};

package/src/utils/package-json.ts

@@ -0,0 +1,75 @@
+import type { PackageJson } from "type-fest";
+
+let packageJSONCache: PackageJson | undefined;
+
+async function readRootPackageJson() {
+	if (packageJSONCache) return packageJSONCache;
+	try {
+		const cwd =
+			typeof process !== "undefined" && typeof process.cwd === "function"
+				? process.cwd()
+				: "";
+		if (!cwd) return undefined;
+		// Lazily import Node built-ins only when available (Node/Bun/Deno) and
+		// avoid static analyzer/bundler resolution by obfuscating module names
+		const importRuntime = (m: string) =>
+			(Function("mm", "return import(mm)") as any)(m);
+		const [{ default: fs }, { default: path }] = await Promise.all([
+			importRuntime("fs/promises"),
+			importRuntime("path"),
+		]);
+		const raw = await fs.readFile(path.join(cwd, "package.json"), "utf-8");
+		packageJSONCache = JSON.parse(raw);
+		return packageJSONCache as PackageJson;
+	} catch {}
+	return undefined;
+}
+
+export async function getPackageVersion(pkg: string) {
+	if (packageJSONCache) {
+		return (packageJSONCache.dependencies?.[pkg] ||
+			packageJSONCache.devDependencies?.[pkg] ||
+			packageJSONCache.peerDependencies?.[pkg]) as string | undefined;
+	}
+
+	try {
+		const cwd =
+			typeof process !== "undefined" && typeof process.cwd === "function"
+				? process.cwd()
+				: "";
+		if (!cwd) throw new Error("no-cwd");
+		const importRuntime = (m: string) =>
+			(Function("mm", "return import(mm)") as any)(m);
+		const [{ default: fs }, { default: path }] = await Promise.all([
+			importRuntime("fs/promises"),
+			importRuntime("path"),
+		]);
+		const pkgJsonPath = path.join(cwd, "node_modules", pkg, "package.json");
+		const raw = await fs.readFile(pkgJsonPath, "utf-8");
+		const json = JSON.parse(raw);
+		const resolved =
+			(json.version as string) ||
+			(await getVersionFromLocalPackageJson(pkg)) ||
+			undefined;
+		return resolved;
+	} catch {}
+
+	const fromRoot = await getVersionFromLocalPackageJson(pkg);
+	return fromRoot;
+}
+
+async function getVersionFromLocalPackageJson(pkg: string) {
+	const json = await readRootPackageJson();
+	if (!json) return undefined;
+	const allDeps = {
+		...json.dependencies,
+		...json.devDependencies,
+		...json.peerDependencies,
+	} as Record<string, string | undefined>;
+	return allDeps[pkg];
+}
+
+export async function getNameFromLocalPackageJson() {
+	const json = await readRootPackageJson();
+	return json?.name as string | undefined;
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "references": [
+    {
+      "path": "../core/tsconfig.json"
+    }
+  ]
+}

package/tsdown.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "tsdown";
+
+export default defineConfig({
+	dts: { build: true, incremental: true },
+	format: ["esm"],
+	entry: ["./src/index.ts"],
+	sourcemap: true,
+});