@better-auth/core 1.5.7-beta.1 → 1.6.0-beta.0

package/src/db/adapter/get-id-field.test.ts

@@ -1,222 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { BetterAuthOptions } from "../../types";
-import type { BetterAuthDBSchema } from "../type";
-import { initGetIdField } from "./get-id-field";
-
-const minimalSchema: BetterAuthDBSchema = {
-	user: {
-		modelName: "user",
-		fields: {
-			name: { type: "string" },
-			email: { type: "string" },
-		},
-	},
-};
-
-const uuidRegex =
-	/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-
-function getField(
-	options: BetterAuthOptions,
-	initExtra?: Partial<Parameters<typeof initGetIdField>[0]>,
-	fieldExtra?: { customModelName?: string; forceAllowId?: boolean },
-) {
-	const idField = initGetIdField({
-		schema: minimalSchema,
-		options,
-		...initExtra,
-	});
-	return idField({
-		customModelName: fieldExtra?.customModelName ?? "user",
-		forceAllowId: fieldExtra?.forceAllowId,
-	});
-}
-
-describe("defaultValue priority", () => {
-	it("should return undefined when disableIdGeneration is true", () => {
-		const field = getField(
-			{ database: {} as any },
-			{ disableIdGeneration: true },
-		);
-		expect(field.defaultValue).toBeUndefined();
-	});
-
-	it("should return undefined when generateId is false", () => {
-		const value = getField({
-			database: {} as any,
-			advanced: { database: { generateId: false } },
-		}).defaultValue?.();
-		expect(value).toBeUndefined();
-	});
-
-	it("should return undefined when generateId is 'serial'", () => {
-		const value = getField({
-			database: {} as any,
-			advanced: { database: { generateId: "serial" } },
-		}).defaultValue?.();
-		expect(value).toBeUndefined();
-	});
-
-	it("should use generateId function over 'uuid' and customIdGenerator", () => {
-		const value = getField(
-			{
-				database: {} as any,
-				advanced: { database: { generateId: () => "fn-id" } },
-			},
-			{ customIdGenerator: () => "adapter-id" },
-		).defaultValue?.();
-		expect(value).toBe("fn-id");
-	});
-
-	it("should use 'uuid' over customIdGenerator", () => {
-		const value = getField(
-			{
-				database: {} as any,
-				advanced: { database: { generateId: "uuid" } },
-			},
-			{ customIdGenerator: () => "adapter-id", supportsUUIDs: false },
-		).defaultValue?.();
-		expect(value).toMatch(uuidRegex);
-	});
-
-	it("should use customIdGenerator when generateId is not set", () => {
-		const value = getField(
-			{ database: {} as any },
-			{ customIdGenerator: () => "adapter-id" },
-		).defaultValue?.();
-		expect(value).toBe("adapter-id");
-	});
-
-	it("should fall back to default id generation", () => {
-		const value = getField({ database: {} as any }).defaultValue?.();
-		expect(typeof value).toBe("string");
-		expect(value).not.toMatch(uuidRegex);
-	});
-});
-
-describe("type and required", () => {
-	it("should have type 'number' when generateId is 'serial'", () => {
-		const field = getField({
-			database: {} as any,
-			advanced: { database: { generateId: "serial" } },
-		});
-		expect(field.type).toBe("number");
-		expect(field.required).toBe(false);
-	});
-
-	it("should have type 'string' by default", () => {
-		const field = getField({ database: {} as any });
-		expect(field.type).toBe("string");
-		expect(field.required).toBe(true);
-	});
-
-	it("should not generate id when useUUIDs and supportsUUIDs", () => {
-		const field = getField(
-			{
-				database: {} as any,
-				advanced: { database: { generateId: "uuid" } },
-			},
-			{ supportsUUIDs: true },
-		);
-		expect(field.required).toBe(false);
-		expect(field.defaultValue).toBeUndefined();
-	});
-});
-
-describe("transform.input", () => {
-	it("should return undefined for falsy value", () => {
-		const field = getField({ database: {} as any });
-		expect(field.transform.input(undefined)).toBeUndefined();
-		expect(field.transform.input(null)).toBeUndefined();
-		expect(field.transform.input("")).toBeUndefined();
-	});
-
-	it("should return value as-is by default", () => {
-		const field = getField({ database: {} as any });
-		expect(field.transform.input("some-id")).toBe("some-id");
-	});
-
-	describe("serial", () => {
-		it("should convert string to number", () => {
-			const field = getField({
-				database: {} as any,
-				advanced: { database: { generateId: "serial" } },
-			});
-			expect(field.transform.input("42")).toBe(42);
-		});
-
-		it("should return undefined for non-numeric string", () => {
-			const field = getField({
-				database: {} as any,
-				advanced: { database: { generateId: "serial" } },
-			});
-			expect(field.transform.input("not-a-number")).toBeUndefined();
-		});
-	});
-
-	describe("uuid", () => {
-		it("should return value as-is when shouldGenerateId and not forceAllowId", () => {
-			const field = getField(
-				{
-					database: {} as any,
-					advanced: { database: { generateId: "uuid" } },
-				},
-				{ supportsUUIDs: false },
-			);
-			const uuid = crypto.randomUUID();
-			expect(field.transform.input(uuid)).toBe(uuid);
-		});
-
-		it("should return undefined when supportsUUIDs (DB handles it)", () => {
-			const field = getField(
-				{
-					database: {} as any,
-					advanced: { database: { generateId: "uuid" } },
-				},
-				{ supportsUUIDs: true },
-			);
-			expect(field.transform.input("some-value")).toBeUndefined();
-		});
-
-		it("should accept valid UUID when forceAllowId is true", () => {
-			const uuid = crypto.randomUUID();
-			const field = getField(
-				{
-					database: {} as any,
-					advanced: { database: { generateId: "uuid" } },
-				},
-				{ supportsUUIDs: false },
-				{ forceAllowId: true },
-			);
-			expect(field.transform.input(uuid)).toBe(uuid);
-		});
-
-		it("should generate new UUID for non-string value when DB doesn't support UUIDs", () => {
-			const field = getField(
-				{
-					database: {} as any,
-					advanced: { database: { generateId: "uuid" } },
-				},
-				{ supportsUUIDs: false },
-				{ forceAllowId: true },
-			);
-			const result = field.transform.input(123);
-			expect(result).toMatch(uuidRegex);
-		});
-	});
-});
-
-describe("transform.output", () => {
-	it("should return undefined for falsy value", () => {
-		const field = getField({ database: {} as any });
-		expect(field.transform.output(undefined)).toBeUndefined();
-		expect(field.transform.output(null)).toBeUndefined();
-		expect(field.transform.output("")).toBeUndefined();
-	});
-
-	it("should convert value to string", () => {
-		const field = getField({ database: {} as any });
-		expect(field.transform.output(123)).toBe("123");
-		expect(field.transform.output("abc")).toBe("abc");
-	});
-});

package/src/db/test/get-tables.test.ts

@@ -1,116 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getAuthTables } from "../get-tables";
-
-describe("getAuthTables", () => {
-	it("should use correct field name for refreshTokenExpiresAt", () => {
-		const tables = getAuthTables({
-			account: {
-				fields: {
-					refreshTokenExpiresAt: "custom_refresh_token_expires_at",
-				},
-			},
-		});
-
-		const accountTable = tables.account;
-		const refreshTokenExpiresAtField =
-			accountTable!.fields.refreshTokenExpiresAt!;
-
-		expect(refreshTokenExpiresAtField.fieldName).toBe(
-			"custom_refresh_token_expires_at",
-		);
-	});
-
-	it("should not use accessTokenExpiresAt field name for refreshTokenExpiresAt", () => {
-		const tables = getAuthTables({
-			account: {
-				fields: {
-					accessTokenExpiresAt: "custom_access_token_expires_at",
-					refreshTokenExpiresAt: "custom_refresh_token_expires_at",
-				},
-			},
-		});
-
-		const accountTable = tables.account;
-		const refreshTokenExpiresAtField =
-			accountTable!.fields.refreshTokenExpiresAt!;
-		const accessTokenExpiresAtField =
-			accountTable!.fields.accessTokenExpiresAt!;
-
-		expect(refreshTokenExpiresAtField.fieldName).toBe(
-			"custom_refresh_token_expires_at",
-		);
-		expect(accessTokenExpiresAtField.fieldName).toBe(
-			"custom_access_token_expires_at",
-		);
-		expect(refreshTokenExpiresAtField.fieldName).not.toBe(
-			accessTokenExpiresAtField.fieldName,
-		);
-	});
-
-	it("should use default field names when no custom names provided", () => {
-		const tables = getAuthTables({});
-
-		const accountTable = tables.account;
-		const refreshTokenExpiresAtField =
-			accountTable!.fields.refreshTokenExpiresAt!;
-		const accessTokenExpiresAtField =
-			accountTable!.fields.accessTokenExpiresAt!;
-
-		expect(refreshTokenExpiresAtField.fieldName).toBe("refreshTokenExpiresAt");
-		expect(accessTokenExpiresAtField.fieldName).toBe("accessTokenExpiresAt");
-	});
-
-	it("should merge additionalFields into verification table metadata", () => {
-		const tables = getAuthTables({
-			verification: {
-				additionalFields: {
-					newField: {
-						fieldName: "new_field",
-						type: "string",
-					},
-				},
-			},
-		});
-
-		const verificationTable = tables.verification;
-		const newField = verificationTable!.fields.newField!;
-
-		console.log(newField);
-		expect(newField).not.toBeUndefined();
-		expect(newField.fieldName).toBe("new_field");
-		expect(newField.type).toBe("string");
-	});
-
-	it("should exclude verification table when secondaryStorage is configured", () => {
-		const tables = getAuthTables({
-			secondaryStorage: {
-				get: async () => null,
-				set: async () => {},
-				delete: async () => {},
-			},
-		});
-
-		expect(tables.verification).toBeUndefined();
-	});
-
-	it("should include verification table when storeInDatabase is true", () => {
-		const tables = getAuthTables({
-			secondaryStorage: {
-				get: async () => null,
-				set: async () => {},
-				delete: async () => {},
-			},
-			verification: {
-				storeInDatabase: true,
-			},
-		});
-
-		expect(tables.verification).toBeDefined();
-	});
-
-	it("should include verification table when no secondaryStorage", () => {
-		const tables = getAuthTables({});
-
-		expect(tables.verification).toBeDefined();
-	});
-});

package/src/env/logger.test.ts

@@ -1,34 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { LogLevel } from "./logger";
-import { shouldPublishLog } from "./logger";
-
-describe("shouldPublishLog", () => {
-	const testCases: {
-		currentLogLevel: LogLevel;
-		logLevel: LogLevel;
-		expected: boolean;
-	}[] = [
-		{ currentLogLevel: "debug", logLevel: "debug", expected: true },
-		{ currentLogLevel: "debug", logLevel: "info", expected: true },
-		{ currentLogLevel: "debug", logLevel: "warn", expected: true },
-		{ currentLogLevel: "debug", logLevel: "error", expected: true },
-		{ currentLogLevel: "info", logLevel: "debug", expected: false },
-		{ currentLogLevel: "info", logLevel: "info", expected: true },
-		{ currentLogLevel: "info", logLevel: "warn", expected: true },
-		{ currentLogLevel: "info", logLevel: "error", expected: true },
-		{ currentLogLevel: "warn", logLevel: "debug", expected: false },
-		{ currentLogLevel: "warn", logLevel: "info", expected: false },
-		{ currentLogLevel: "warn", logLevel: "warn", expected: true },
-		{ currentLogLevel: "warn", logLevel: "error", expected: true },
-		{ currentLogLevel: "error", logLevel: "debug", expected: false },
-		{ currentLogLevel: "error", logLevel: "info", expected: false },
-		{ currentLogLevel: "error", logLevel: "warn", expected: false },
-		{ currentLogLevel: "error", logLevel: "error", expected: true },
-	];
-
-	testCases.forEach(({ currentLogLevel, logLevel, expected }) => {
-		it(`should return "${expected}" when currentLogLevel is "${currentLogLevel}" and logLevel is "${logLevel}"`, () => {
-			expect(shouldPublishLog(currentLogLevel, logLevel)).toBe(expected);
-		});
-	});
-});

package/src/instrumentation/instrumentation.test.ts

@@ -1,139 +0,0 @@
-import { trace } from "@opentelemetry/api";
-import {
-	InMemorySpanExporter,
-	SimpleSpanProcessor,
-} from "@opentelemetry/sdk-trace-base";
-import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
-import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
-import { withSpan } from ".";
-import { ATTR_DB_COLLECTION_NAME, ATTR_DB_OPERATION_NAME } from "./attributes";
-
-describe("instrumentation", () => {
-	let provider: NodeTracerProvider;
-	let exporter: InMemorySpanExporter;
-
-	beforeAll(async () => {
-		exporter = new InMemorySpanExporter();
-		provider = new NodeTracerProvider({
-			spanProcessors: [new SimpleSpanProcessor(exporter)],
-		});
-		trace.setGlobalTracerProvider(provider);
-	});
-
-	afterAll(async () => {
-		await provider.shutdown();
-	});
-
-	beforeEach(() => {
-		exporter.reset();
-	});
-
-	it("creates a span with name and attributes for sync function", () => {
-		const result = withSpan(
-			"test.sync",
-			{
-				[ATTR_DB_OPERATION_NAME]: "findOne",
-				[ATTR_DB_COLLECTION_NAME]: "user",
-			},
-			() => 42,
-		);
-
-		expect(result).toBe(42);
-
-		const spans = exporter.getFinishedSpans();
-		expect(spans).toHaveLength(1);
-		expect(spans[0]?.name).toBe("test.sync");
-		expect(spans[0]?.attributes).toMatchObject({
-			[ATTR_DB_OPERATION_NAME]: "findOne",
-			[ATTR_DB_COLLECTION_NAME]: "user",
-		});
-	});
-
-	it("creates a span for async function", async () => {
-		const result = await withSpan(
-			"test.async",
-			{ endpoint: "getSession" },
-			async () => {
-				await new Promise((r) => setTimeout(r, 5));
-				return "session-id";
-			},
-		);
-
-		expect(result).toBe("session-id");
-
-		const spans = exporter.getFinishedSpans();
-		expect(spans).toHaveLength(1);
-		expect(spans[0]?.name).toBe("test.async");
-		expect(spans[0]?.attributes).toMatchObject({ endpoint: "getSession" });
-	});
-
-	it("records error status and exception when sync function throws", () => {
-		const err = new Error("sync failure");
-
-		expect(() =>
-			withSpan("test.sync.error", { foo: "bar" }, () => {
-				throw err;
-			}),
-		).toThrow("sync failure");
-
-		const spans = exporter.getFinishedSpans();
-		expect(spans).toHaveLength(1);
-		expect(spans[0]?.name).toBe("test.sync.error");
-		expect(spans[0]?.status).toMatchObject({
-			code: 2,
-			message: "sync failure",
-		});
-	});
-
-	it("records error status and exception when async function rejects", async () => {
-		const err = new Error("async failure");
-
-		await expect(
-			withSpan("test.async.error", { baz: 1 }, async () => {
-				await Promise.resolve();
-				throw err;
-			}),
-		).rejects.toThrow("async failure");
-
-		const spans = exporter.getFinishedSpans();
-		expect(spans).toHaveLength(1);
-		expect(spans[0]?.name).toBe("test.async.error");
-		expect(spans[0]?.status).toMatchObject({
-			code: 2,
-			message: "async failure",
-		});
-	});
-
-	it("creates multiple sequential spans", () => {
-		void withSpan("first", { order: 1 }, () => 1);
-		void withSpan("second", { order: 2 }, () => 2);
-
-		const spans = exporter.getFinishedSpans();
-		expect(spans).toHaveLength(2);
-		expect(spans.map((s) => s.name)).toEqual(
-			expect.arrayContaining(["first", "second"]),
-		);
-	});
-
-	it("creates nested spans when withSpan is composed", () => {
-		const result = withSpan("outer", { depth: 0 }, () => {
-			return withSpan("inner", { depth: 1 }, () => "ok");
-		});
-
-		expect(result).toBe("ok");
-
-		const spans = exporter.getFinishedSpans();
-		expect(spans).toHaveLength(2);
-		expect(spans.map((s) => s.name).sort()).toEqual(["inner", "outer"]);
-	});
-
-	it("uses better-auth instrumentation scope", () => {
-		void withSpan("scope.check", {}, () => undefined);
-
-		const spans = exporter.getFinishedSpans();
-		expect(spans).toHaveLength(1);
-
-		const span = spans[0];
-		expect(span?.instrumentationLibrary?.name).toBe("better-auth");
-	});
-});

package/src/oauth2/refresh-access-token.test.ts

@@ -1,90 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-vi.mock("@better-fetch/fetch", () => ({
-	betterFetch: vi.fn(),
-}));
-
-import { betterFetch } from "@better-fetch/fetch";
-import { refreshAccessToken } from "./refresh-access-token";
-
-const mockedBetterFetch = vi.mocked(betterFetch);
-
-describe("refreshAccessToken", () => {
-	it("should set accessTokenExpiresAt when expires_in is returned", async () => {
-		const now = Date.now();
-		mockedBetterFetch.mockResolvedValueOnce({
-			data: {
-				access_token: "new-access-token",
-				refresh_token: "new-refresh-token",
-				expires_in: 3600,
-				token_type: "Bearer",
-			},
-			error: null,
-		});
-
-		const tokens = await refreshAccessToken({
-			refreshToken: "old-refresh-token",
-			options: { clientId: "test-client", clientSecret: "test-secret" },
-			tokenEndpoint: "https://example.com/token",
-		});
-
-		expect(tokens.accessToken).toBe("new-access-token");
-		expect(tokens.refreshToken).toBe("new-refresh-token");
-		expect(tokens.accessTokenExpiresAt).toBeInstanceOf(Date);
-		expect(tokens.accessTokenExpiresAt!.getTime()).toBeGreaterThanOrEqual(
-			now + 3600 * 1000 - 1000,
-		);
-		expect(tokens.refreshTokenExpiresAt).toBeUndefined();
-	});
-
-	/**
-	 * @see https://github.com/better-auth/better-auth/issues/7682
-	 */
-	it("should set refreshTokenExpiresAt when refresh_token_expires_in is returned", async () => {
-		const now = Date.now();
-		mockedBetterFetch.mockResolvedValueOnce({
-			data: {
-				access_token: "new-access-token",
-				refresh_token: "new-refresh-token",
-				expires_in: 3600,
-				refresh_token_expires_in: 86400,
-				token_type: "Bearer",
-			},
-			error: null,
-		});
-
-		const tokens = await refreshAccessToken({
-			refreshToken: "old-refresh-token",
-			options: { clientId: "test-client", clientSecret: "test-secret" },
-			tokenEndpoint: "https://example.com/token",
-		});
-
-		expect(tokens.accessToken).toBe("new-access-token");
-		expect(tokens.refreshToken).toBe("new-refresh-token");
-		expect(tokens.accessTokenExpiresAt).toBeInstanceOf(Date);
-		expect(tokens.refreshTokenExpiresAt).toBeInstanceOf(Date);
-		expect(tokens.refreshTokenExpiresAt!.getTime()).toBeGreaterThanOrEqual(
-			now + 86400 * 1000 - 1000,
-		);
-	});
-
-	it("should not set refreshTokenExpiresAt when refresh_token_expires_in is not returned", async () => {
-		mockedBetterFetch.mockResolvedValueOnce({
-			data: {
-				access_token: "new-access-token",
-				refresh_token: "new-refresh-token",
-				expires_in: 3600,
-				token_type: "Bearer",
-			},
-			error: null,
-		});
-
-		const tokens = await refreshAccessToken({
-			refreshToken: "old-refresh-token",
-			options: { clientId: "test-client", clientSecret: "test-secret" },
-			tokenEndpoint: "https://example.com/token",
-		});
-
-		expect(tokens.refreshTokenExpiresAt).toBeUndefined();
-	});
-});