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

package/src/db/type.ts

@@ -0,0 +1,180 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import type { Awaitable, LiteralString } from "../types";
+
+export type BaseModelNames = "user" | "account" | "session" | "verification";
+
+export type ModelNames<T extends string = LiteralString> =
+	| BaseModelNames
+	| T
+	| "rate-limit";
+
+export type DBFieldType =
+	| "string"
+	| "number"
+	| "boolean"
+	| "date"
+	| "json"
+	| `${"string" | "number"}[]`
+	| Array<LiteralString>;
+
+export type DBPrimitive =
+	| string
+	| number
+	| boolean
+	| Date
+	| null
+	| undefined
+	| string[]
+	| number[]
+	| (Record<string, unknown> | unknown[]);
+
+export type DBFieldAttributeConfig = {
+	/**
+	 * If the field should be required on a new record.
+	 * @default true
+	 */
+	required?: boolean | undefined;
+	/**
+	 * If the value should be returned on a response body.
+	 * @default true
+	 */
+	returned?: boolean | undefined;
+	/**
+	 * If a value should be provided when creating a new record.
+	 * @default true
+	 */
+	input?: boolean | undefined;
+	/**
+	 * Default value for the field
+	 *
+	 * Note: This will not create a default value on the database level. It will only
+	 * be used when creating a new record.
+	 */
+	defaultValue?: (DBPrimitive | (() => DBPrimitive)) | undefined;
+	/**
+	 * Update value for the field
+	 *
+	 * Note: This will create an onUpdate trigger on the database level for supported adapters.
+	 * It will be called when updating a record.
+	 */
+	onUpdate?: (() => DBPrimitive) | undefined;
+	/**
+	 * transform the value before storing it.
+	 */
+	transform?:
+		| {
+				input?: (value: DBPrimitive) => Awaitable<DBPrimitive>;
+				output?: (value: DBPrimitive) => Awaitable<DBPrimitive>;
+		  }
+		| undefined;
+	/**
+	 * Reference to another model.
+	 */
+	references?:
+		| {
+				/**
+				 * The model to reference.
+				 */
+				model: string;
+				/**
+				 * The field on the referenced model.
+				 */
+				field: string;
+				/**
+				 * The action to perform when the reference is deleted.
+				 * @default "cascade"
+				 */
+				onDelete?:
+					| "no action"
+					| "restrict"
+					| "cascade"
+					| "set null"
+					| "set default";
+		  }
+		| undefined;
+	unique?: boolean | undefined;
+	/**
+	 * If the field should be a bigint on the database instead of integer.
+	 */
+	bigint?: boolean | undefined;
+	/**
+	 * A zod schema to validate the value.
+	 */
+	validator?:
+		| {
+				input?: StandardSchemaV1;
+				output?: StandardSchemaV1;
+		  }
+		| undefined;
+	/**
+	 * The name of the field on the database.
+	 */
+	fieldName?: string | undefined;
+	/**
+	 * If the field should be sortable.
+	 *
+	 * applicable only for `text` type.
+	 * It's useful to mark fields varchar instead of text.
+	 */
+	sortable?: boolean | undefined;
+	/**
+	 * If the field should be indexed.
+	 * @default false
+	 */
+	index?: boolean | undefined;
+};
+
+export type DBFieldAttribute<T extends DBFieldType = DBFieldType> = {
+	type: T;
+} & DBFieldAttributeConfig;
+
+export type BetterAuthDBSchema = Record<
+	string,
+	{
+		/**
+		 * The name of the table in the database
+		 */
+		modelName: string;
+		/**
+		 * The fields of the table
+		 */
+		fields: Record<string, DBFieldAttribute>;
+		/**
+		 * Whether to disable migrations for this table
+		 * @default false
+		 */
+		disableMigrations?: boolean | undefined;
+		/**
+		 * The order of the table
+		 */
+		order?: number | undefined;
+	}
+>;
+
+export interface SecondaryStorage {
+	/**
+	 *
+	 * @param key - Key to get
+	 * @returns - Value of the key
+	 */
+	get: (key: string) => Awaitable<unknown>;
+	set: (
+		/**
+		 * Key to store
+		 */
+		key: string,
+		/**
+		 * Value to store
+		 */
+		value: string,
+		/**
+		 * Time to live in seconds
+		 */
+		ttl?: number | undefined,
+	) => Awaitable<void | null | unknown>;
+	/**
+	 *
+	 * @param key - Key to delete
+	 */
+	delete: (key: string) => Awaitable<void | null | string>;
+}

package/src/env/color-depth.ts

@@ -0,0 +1,172 @@
+// Source code copied & modified from node internals: https://github.com/nodejs/node/blob/5b32bb1573dace2dd058c05ac4fab1e4e446c775/lib/internal/tty.js#L123
+import { env, getEnvVar } from "./env-impl";
+
+const COLORS_2 = 1;
+const COLORS_16 = 4;
+const COLORS_256 = 8;
+const COLORS_16m = 24;
+
+const TERM_ENVS: Record<string, number> = {
+	eterm: COLORS_16,
+	cons25: COLORS_16,
+	console: COLORS_16,
+	cygwin: COLORS_16,
+	dtterm: COLORS_16,
+	gnome: COLORS_16,
+	hurd: COLORS_16,
+	jfbterm: COLORS_16,
+	konsole: COLORS_16,
+	kterm: COLORS_16,
+	mlterm: COLORS_16,
+	mosh: COLORS_16m,
+	putty: COLORS_16,
+	st: COLORS_16,
+	// http://lists.schmorp.de/pipermail/rxvt-unicode/2016q2/002261.html
+	"rxvt-unicode-24bit": COLORS_16m,
+	// https://bugs.launchpad.net/terminator/+bug/1030562
+	terminator: COLORS_16m,
+	"xterm-kitty": COLORS_16m,
+};
+
+const CI_ENVS_MAP = new Map(
+	Object.entries({
+		APPVEYOR: COLORS_256,
+		BUILDKITE: COLORS_256,
+		CIRCLECI: COLORS_16m,
+		DRONE: COLORS_256,
+		GITEA_ACTIONS: COLORS_16m,
+		GITHUB_ACTIONS: COLORS_16m,
+		GITLAB_CI: COLORS_256,
+		TRAVIS: COLORS_256,
+	}),
+);
+
+const TERM_ENVS_REG_EXP = [
+	/ansi/,
+	/color/,
+	/linux/,
+	/direct/,
+	/^con[0-9]*x[0-9]/,
+	/^rxvt/,
+	/^screen/,
+	/^xterm/,
+	/^vt100/,
+	/^vt220/,
+];
+
+// The `getColorDepth` API got inspired by multiple sources such as
+// https://github.com/chalk/supports-color,
+// https://github.com/isaacs/color-support.
+export function getColorDepth(): number {
+	// Use level 0-3 to support the same levels as `chalk` does. This is done for
+	// consistency throughout the ecosystem.
+	if (getEnvVar("FORCE_COLOR") !== undefined) {
+		switch (getEnvVar("FORCE_COLOR")) {
+			case "":
+			case "1":
+			case "true":
+				return COLORS_16;
+			case "2":
+				return COLORS_256;
+			case "3":
+				return COLORS_16m;
+			default:
+				return COLORS_2;
+		}
+	}
+
+	if (
+		(getEnvVar("NODE_DISABLE_COLORS") !== undefined &&
+			getEnvVar("NODE_DISABLE_COLORS") !== "") ||
+		// See https://no-color.org/
+		(getEnvVar("NO_COLOR") !== undefined && getEnvVar("NO_COLOR") !== "") ||
+		// The "dumb" special terminal, as defined by terminfo, doesn't support
+		// ANSI color control codes.
+		// See https://invisible-island.net/ncurses/terminfo.ti.html#toc-_Specials
+		getEnvVar("TERM") === "dumb"
+	) {
+		return COLORS_2;
+	}
+
+	// Edge runtime doesn't support `process?.platform` syntax
+	// if (typeof process !== "undefined" && process?.platform === "win32") {
+	// 	// Windows 10 build 14931 (from 2016) has true color support
+	// 	return COLORS_16m;
+	// }
+
+	if (getEnvVar("TMUX")) {
+		return COLORS_16m;
+	}
+
+	// Azure DevOps
+	if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+		return COLORS_16;
+	}
+
+	if ("CI" in env) {
+		for (const { 0: envName, 1: colors } of CI_ENVS_MAP) {
+			if (envName in env) {
+				return colors;
+			}
+		}
+		if (getEnvVar("CI_NAME") === "codeship") {
+			return COLORS_256;
+		}
+		return COLORS_2;
+	}
+
+	if ("TEAMCITY_VERSION" in env) {
+		return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.exec(
+			getEnvVar("TEAMCITY_VERSION"),
+		) !== null
+			? COLORS_16
+			: COLORS_2;
+	}
+
+	switch (getEnvVar("TERM_PROGRAM")) {
+		case "iTerm.app":
+			if (
+				!getEnvVar("TERM_PROGRAM_VERSION") ||
+				/^[0-2]\./.exec(getEnvVar("TERM_PROGRAM_VERSION")) !== null
+			) {
+				return COLORS_256;
+			}
+			return COLORS_16m;
+		case "HyperTerm":
+		case "MacTerm":
+			return COLORS_16m;
+		case "Apple_Terminal":
+			return COLORS_256;
+	}
+
+	if (
+		getEnvVar("COLORTERM") === "truecolor" ||
+		getEnvVar("COLORTERM") === "24bit"
+	) {
+		return COLORS_16m;
+	}
+
+	if (getEnvVar("TERM")) {
+		if (/truecolor/.exec(getEnvVar("TERM")) !== null) {
+			return COLORS_16m;
+		}
+
+		if (/^xterm-256/.exec(getEnvVar("TERM")) !== null) {
+			return COLORS_256;
+		}
+
+		const termEnv = getEnvVar("TERM").toLowerCase();
+
+		if (TERM_ENVS[termEnv]) {
+			return TERM_ENVS[termEnv];
+		}
+		if (TERM_ENVS_REG_EXP.some((term) => term.exec(termEnv) !== null)) {
+			return COLORS_16;
+		}
+	}
+	// Move 16 color COLORTERM below 16m and 256
+	if (getEnvVar("COLORTERM")) {
+		return COLORS_16;
+	}
+	return COLORS_2;
+}

package/src/env/env-impl.ts

@@ -0,0 +1,124 @@
+/// <reference types="node" />
+/// <reference types="bun" />
+//https://github.com/unjs/std-env/blob/main/src/env.ts
+
+const _envShim = Object.create(null);
+
+export type EnvObject = Record<string, string | undefined>;
+
+const _getEnv = (useShim?: boolean) =>
+	globalThis.process?.env ||
+	//@ts-expect-error
+	globalThis.Deno?.env.toObject() ||
+	//@ts-expect-error
+	globalThis.__env__ ||
+	(useShim ? _envShim : globalThis);
+
+export const env = new Proxy<EnvObject>(_envShim, {
+	get(_, prop) {
+		const env = _getEnv();
+		return env[prop as any] ?? _envShim[prop];
+	},
+	has(_, prop) {
+		const env = _getEnv();
+		return prop in env || prop in _envShim;
+	},
+	set(_, prop, value) {
+		const env = _getEnv(true);
+		env[prop as any] = value;
+		return true;
+	},
+	deleteProperty(_, prop) {
+		if (!prop) {
+			return false;
+		}
+		const env = _getEnv(true);
+		delete env[prop as any];
+		return true;
+	},
+	ownKeys() {
+		const env = _getEnv(true);
+		return Object.keys(env);
+	},
+});
+
+function toBoolean(val: boolean | string | undefined) {
+	return val ? val !== "false" : false;
+}
+
+export const nodeENV =
+	(typeof process !== "undefined" && process.env && process.env.NODE_ENV) || "";
+
+/** Detect if `NODE_ENV` environment variable is `production` */
+export const isProduction = nodeENV === "production";
+
+/** Detect if `NODE_ENV` environment variable is `dev` or `development` */
+export const isDevelopment = () =>
+	nodeENV === "dev" || nodeENV === "development";
+
+/** Detect if `NODE_ENV` environment variable is `test` */
+export const isTest = () => nodeENV === "test" || toBoolean(env.TEST);
+
+/**
+ * Get environment variable with fallback
+ */
+export function getEnvVar<Fallback extends string>(
+	key: string,
+	fallback?: Fallback,
+): Fallback extends string ? string : string | undefined {
+	if (typeof process !== "undefined" && process.env) {
+		return process.env[key] ?? (fallback as any);
+	}
+
+	// @ts-expect-error deno
+	if (typeof Deno !== "undefined") {
+		// @ts-expect-error deno
+		return Deno.env.get(key) ?? (fallback as string);
+	}
+
+	// Handle Bun
+	if (typeof Bun !== "undefined") {
+		return Bun.env[key] ?? (fallback as string);
+	}
+
+	return fallback as any;
+}
+
+/**
+ * Get boolean environment variable
+ */
+export function getBooleanEnvVar(key: string, fallback = true): boolean {
+	const value = getEnvVar(key);
+	if (!value) return fallback;
+	return value !== "0" && value.toLowerCase() !== "false" && value !== "";
+}
+
+/**
+ * Common environment variables used in Better Auth
+ */
+export const ENV = Object.freeze({
+	get BETTER_AUTH_SECRET() {
+		return getEnvVar("BETTER_AUTH_SECRET");
+	},
+	get AUTH_SECRET() {
+		return getEnvVar("AUTH_SECRET");
+	},
+	get BETTER_AUTH_TELEMETRY() {
+		return getEnvVar("BETTER_AUTH_TELEMETRY");
+	},
+	get BETTER_AUTH_TELEMETRY_ID() {
+		return getEnvVar("BETTER_AUTH_TELEMETRY_ID");
+	},
+	get NODE_ENV() {
+		return getEnvVar("NODE_ENV", "development");
+	},
+	get PACKAGE_VERSION() {
+		return getEnvVar("PACKAGE_VERSION", "0.0.0");
+	},
+	get BETTER_AUTH_TELEMETRY_ENDPOINT(): string | undefined {
+		return getEnvVar(
+			"BETTER_AUTH_TELEMETRY_ENDPOINT",
+			import.meta.env.BETTER_AUTH_TELEMETRY_ENDPOINT,
+		);
+	},
+});

package/src/env/index.ts

@@ -0,0 +1,23 @@
+export { getColorDepth } from "./color-depth";
+export {
+	ENV,
+	type EnvObject,
+	env,
+	getBooleanEnvVar,
+	getEnvVar,
+	isDevelopment,
+	isProduction,
+	isTest,
+	nodeENV,
+} from "./env-impl";
+export {
+	createLogger,
+	type InternalLogger,
+	type Logger,
+	type LogHandlerParams,
+	type LogLevel,
+	levels,
+	logger,
+	shouldPublishLog,
+	TTY_COLORS,
+} from "./logger";

package/src/env/logger.test.ts

@@ -0,0 +1,34 @@
+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/env/logger.ts

@@ -0,0 +1,145 @@
+import { getColorDepth } from "./color-depth";
+
+export const TTY_COLORS = {
+	reset: "\x1b[0m",
+	bright: "\x1b[1m",
+	dim: "\x1b[2m",
+	undim: "\x1b[22m",
+	underscore: "\x1b[4m",
+	blink: "\x1b[5m",
+	reverse: "\x1b[7m",
+	hidden: "\x1b[8m",
+	fg: {
+		black: "\x1b[30m",
+		red: "\x1b[31m",
+		green: "\x1b[32m",
+		yellow: "\x1b[33m",
+		blue: "\x1b[34m",
+		magenta: "\x1b[35m",
+		cyan: "\x1b[36m",
+		white: "\x1b[37m",
+	},
+	bg: {
+		black: "\x1b[40m",
+		red: "\x1b[41m",
+		green: "\x1b[42m",
+		yellow: "\x1b[43m",
+		blue: "\x1b[44m",
+		magenta: "\x1b[45m",
+		cyan: "\x1b[46m",
+		white: "\x1b[47m",
+	},
+} as const;
+
+export type LogLevel = "debug" | "info" | "success" | "warn" | "error";
+
+export const levels = ["debug", "info", "success", "warn", "error"] as const;
+
+export function shouldPublishLog(
+	currentLogLevel: LogLevel,
+	logLevel: LogLevel,
+): boolean {
+	return levels.indexOf(logLevel) >= levels.indexOf(currentLogLevel);
+}
+
+export interface Logger {
+	disabled?: boolean | undefined;
+	disableColors?: boolean | undefined;
+	level?: Exclude<LogLevel, "success"> | undefined;
+	log?:
+		| ((
+				level: Exclude<LogLevel, "success">,
+				message: string,
+				...args: any[]
+		  ) => void)
+		| undefined;
+}
+
+export type LogHandlerParams =
+	Parameters<NonNullable<Logger["log"]>> extends [LogLevel, ...infer Rest]
+		? Rest
+		: never;
+
+const levelColors: Record<LogLevel, string> = {
+	info: TTY_COLORS.fg.blue,
+	success: TTY_COLORS.fg.green,
+	warn: TTY_COLORS.fg.yellow,
+	error: TTY_COLORS.fg.red,
+	debug: TTY_COLORS.fg.magenta,
+};
+
+const formatMessage = (
+	level: LogLevel,
+	message: string,
+	colorsEnabled: boolean,
+): string => {
+	const timestamp = new Date().toISOString();
+
+	if (colorsEnabled) {
+		return `${TTY_COLORS.dim}${timestamp}${TTY_COLORS.reset} ${
+			levelColors[level]
+		}${level.toUpperCase()}${TTY_COLORS.reset} ${TTY_COLORS.bright}[Better Auth]:${
+			TTY_COLORS.reset
+		} ${message}`;
+	}
+
+	return `${timestamp} ${level.toUpperCase()} [Better Auth]: ${message}`;
+};
+
+export type InternalLogger = {
+	[K in LogLevel]: (...params: LogHandlerParams) => void;
+} & {
+	get level(): LogLevel;
+};
+
+export const createLogger = (options?: Logger | undefined): InternalLogger => {
+	const enabled = options?.disabled !== true;
+	const logLevel = options?.level ?? "warn";
+
+	const isDisableColorsSpecified = options?.disableColors !== undefined;
+	const colorsEnabled = isDisableColorsSpecified
+		? !options.disableColors
+		: getColorDepth() !== 1;
+
+	const LogFunc = (
+		level: LogLevel,
+		message: string,
+		args: any[] = [],
+	): void => {
+		if (!enabled || !shouldPublishLog(logLevel, level)) {
+			return;
+		}
+
+		const formattedMessage = formatMessage(level, message, colorsEnabled);
+
+		if (!options || typeof options.log !== "function") {
+			if (level === "error") {
+				console.error(formattedMessage, ...args);
+			} else if (level === "warn") {
+				console.warn(formattedMessage, ...args);
+			} else {
+				console.log(formattedMessage, ...args);
+			}
+			return;
+		}
+
+		options.log(level === "success" ? "info" : level, message, ...args);
+	};
+
+	const logger = Object.fromEntries(
+		levels.map((level) => [
+			level,
+			(...[message, ...args]: LogHandlerParams) =>
+				LogFunc(level, message, args),
+		]),
+	) as Record<LogLevel, (...params: LogHandlerParams) => void>;
+
+	return {
+		...logger,
+		get level() {
+			return logLevel;
+		},
+	};
+};
+
+export const logger = createLogger();