@gatwech/core 0.0.1-beta.1

package/.turbo/turbo-build.log

@@ -0,0 +1,42 @@
+
+> @gatwech/core@0.0.1-beta.1 build /home/runner/work/payvo-auth/payvo-auth/packages/core
+> tsdown
+
+ℹ tsdown v0.16.1 powered by rolldown v1.0.0-beta.47
+ℹ Using tsdown config: /home/runner/work/payvo-auth/payvo-auth/packages/core/tsdown.config.ts
+ℹ entry: src/index.ts, src/api/index.ts, src/async_hooks/index.ts, src/context/index.ts, src/db/index.ts, src/env/index.ts, src/error/index.ts, src/oauth2/index.ts, src/social-providers/index.ts, src/utils/index.ts, src/db/adapter/index.ts
+ℹ tsconfig: tsconfig.json
+ℹ Build start
+ℹ dist/social-providers/index.mjs     77.58 kB │ gzip: 10.13 kB
+ℹ dist/db/index.mjs                    1.64 kB │ gzip:  0.50 kB
+ℹ dist/api/index.mjs                   0.83 kB │ gzip:  0.40 kB
+ℹ dist/context/index.mjs               0.74 kB │ gzip:  0.27 kB
+ℹ dist/oauth2/index.mjs                0.61 kB │ gzip:  0.24 kB
+ℹ dist/env/index.mjs                   0.44 kB │ gzip:  0.25 kB
+ℹ dist/error/index.mjs                 0.16 kB │ gzip:  0.13 kB
+ℹ dist/async_hooks/index.mjs           0.11 kB │ gzip:  0.10 kB
+ℹ dist/utils/index.mjs                 0.09 kB │ gzip:  0.09 kB
+ℹ dist/db/adapter/index.mjs            0.01 kB │ gzip:  0.03 kB
+ℹ dist/index.mjs                       0.01 kB │ gzip:  0.03 kB
+ℹ dist/oauth2-DyI7_CNv.mjs             9.16 kB │ gzip:  2.13 kB
+ℹ dist/env-JMSMESs1.mjs                7.67 kB │ gzip:  2.55 kB
+ℹ dist/context-DxzHfoWW.mjs            3.91 kB │ gzip:  1.03 kB
+ℹ dist/error-41YsFQ8b.mjs              1.76 kB │ gzip:  0.79 kB
+ℹ dist/async_hooks-BrLqUNsE.mjs        0.86 kB │ gzip:  0.46 kB
+ℹ dist/utils-BFQCAfNW.mjs              0.13 kB │ gzip:  0.12 kB
+ℹ dist/social-providers/index.d.mts    3.78 kB │ gzip:  1.17 kB
+ℹ dist/context/index.d.mts             2.74 kB │ gzip:  0.78 kB
+ℹ dist/error/index.d.mts               1.84 kB │ gzip:  0.72 kB
+ℹ dist/db/index.d.mts                  1.00 kB │ gzip:  0.38 kB
+ℹ dist/utils/index.d.mts               0.84 kB │ gzip:  0.43 kB
+ℹ dist/index.d.mts                     0.81 kB │ gzip:  0.32 kB
+ℹ dist/oauth2/index.d.mts              0.79 kB │ gzip:  0.29 kB
+ℹ dist/env/index.d.mts                 0.59 kB │ gzip:  0.30 kB
+ℹ dist/db/adapter/index.d.mts          0.47 kB │ gzip:  0.22 kB
+ℹ dist/api/index.d.mts                 0.29 kB │ gzip:  0.15 kB
+ℹ dist/async_hooks/index.d.mts         0.14 kB │ gzip:  0.10 kB
+ℹ dist/index-DjrJweYn.d.mts          204.61 kB │ gzip: 31.91 kB
+ℹ dist/index-DLP-K0uY.d.mts            3.31 kB │ gzip:  1.12 kB
+ℹ dist/index-CRg-E-VF.d.mts            0.24 kB │ gzip:  0.16 kB
+ℹ 31 files, total: 327.18 kB
+✔ Build complete in 6541ms

package/dist/api/index.d.mts

@@ -0,0 +1,3 @@
+import { a as optionsMiddleware, i as createAuthMiddleware, n as AuthMiddleware, r as createAuthEndpoint, t as AuthEndpoint } from "../index-DjrJweYn.mjs";
+import "../index-DLP-K0uY.mjs";
+export { AuthEndpoint, AuthMiddleware, createAuthEndpoint, createAuthMiddleware, optionsMiddleware };

package/dist/api/index.mjs

@@ -0,0 +1,26 @@
+import "../async_hooks-BrLqUNsE.mjs";
+import { f as runWithEndpointContext } from "../context-DxzHfoWW.mjs";
+import { createEndpoint, createMiddleware } from "better-call";
+
+//#region src/api/index.ts
+const optionsMiddleware = createMiddleware(async () => {
+	/**
+	* This will be passed on the instance of
+	* the context. Used to infer the type
+	* here.
+	*/
+	return {};
+});
+const createAuthMiddleware = createMiddleware.create({ use: [optionsMiddleware, createMiddleware(async () => {
+	return {};
+})] });
+const use = [optionsMiddleware];
+const createAuthEndpoint = (path, options, handler) => {
+	return createEndpoint(path, {
+		...options,
+		use: [...options?.use || [], ...use]
+	}, async (ctx) => runWithEndpointContext(ctx, () => handler(ctx)));
+};
+
+//#endregion
+export { createAuthEndpoint, createAuthMiddleware, optionsMiddleware };

package/dist/async_hooks/index.d.mts

@@ -0,0 +1,2 @@
+import { n as getAsyncLocalStorage, t as AsyncLocalStorage } from "../index-CRg-E-VF.mjs";
+export { AsyncLocalStorage, getAsyncLocalStorage };

package/dist/async_hooks/index.mjs

@@ -0,0 +1,3 @@
+import { t as getAsyncLocalStorage } from "../async_hooks-BrLqUNsE.mjs";
+
+export { getAsyncLocalStorage };

package/dist/async_hooks-BrLqUNsE.mjs

@@ -0,0 +1,18 @@
+//#region src/async_hooks/index.ts
+const AsyncLocalStoragePromise = import(
+	/* @vite-ignore */
+	/* webpackIgnore: true */
+	"node:async_hooks"
+).then((mod) => mod.AsyncLocalStorage).catch((err) => {
+	if ("AsyncLocalStorage" in globalThis) return globalThis.AsyncLocalStorage;
+	console.warn("[payvo-auth] Warning: AsyncLocalStorage is not available in this environment. Some features may not work as expected.");
+	console.warn("[payvo-auth] Please read more about this warning at https://payvo-auth.com/docs/installation#mount-handler");
+	console.warn("[payvo-auth] If you are using Cloudflare Workers, please see: https://developers.cloudflare.com/workers/configuration/compatibility-flags/#nodejs-compatibility-flag");
+	throw err;
+});
+async function getAsyncLocalStorage() {
+	return AsyncLocalStoragePromise;
+}
+
+//#endregion
+export { getAsyncLocalStorage as t };

package/dist/context/index.d.mts

@@ -0,0 +1,44 @@
+import { Jn as DBTransactionAdapter, Un as DBAdapter, d as AuthContext } from "../index-DjrJweYn.mjs";
+import "../index-DLP-K0uY.mjs";
+import { t as AsyncLocalStorage } from "../index-CRg-E-VF.mjs";
+import { EndpointContext, InputContext } from "better-call";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/context/endpoint-context.d.ts
+type AuthEndpointContext = Partial<InputContext<string, any> & EndpointContext<string, any>> & {
+  context: AuthContext;
+};
+/**
+ * This is for internal use only. Most users should use `getCurrentAuthContext` instead.
+ *
+ * It is exposed for advanced use cases where you need direct access to the AsyncLocalStorage instance.
+ */
+declare function getCurrentAuthContextAsyncLocalStorage(): Promise<AsyncLocalStorage<AuthEndpointContext>>;
+declare function getCurrentAuthContext(): Promise<AuthEndpointContext>;
+declare function runWithEndpointContext<T>(context: AuthEndpointContext, fn: () => T): Promise<T>;
+//#endregion
+//#region src/context/request-state.d.ts
+type RequestStateWeakMap = WeakMap<StandardSchemaV1, any>;
+declare function getRequestStateAsyncLocalStorage(): Promise<AsyncLocalStorage<RequestStateWeakMap>>;
+declare function hasRequestState(): Promise<boolean>;
+declare function getCurrentRequestState(): Promise<RequestStateWeakMap>;
+declare function runWithRequestState<T>(store: RequestStateWeakMap, fn: () => T): Promise<T>;
+interface RequestState<T> {
+  get<S>(): Promise<S & T>;
+  set(value: T): Promise<void>;
+}
+declare function defineRequestState<T>(schema?: StandardSchemaV1<T>): RequestState<T>;
+declare function defineRequestState<Schema extends StandardSchemaV1>(schema?: Schema): RequestState<StandardSchemaV1.InferInput<Schema>>;
+//#endregion
+//#region src/context/transaction.d.ts
+/**
+ * This is for internal use only. Most users should use `getCurrentAdapter` instead.
+ *
+ * It is exposed for advanced use cases where you need direct access to the AsyncLocalStorage instance.
+ */
+declare const getCurrentDBAdapterAsyncLocalStorage: () => Promise<AsyncLocalStorage<DBTransactionAdapter>>;
+declare const getCurrentAdapter: (fallback: DBTransactionAdapter) => Promise<DBTransactionAdapter>;
+declare const runWithAdapter: <R>(adapter: DBAdapter, fn: () => R) => Promise<R>;
+declare const runWithTransaction: <R>(adapter: DBAdapter, fn: () => R) => Promise<R>;
+//#endregion
+export { type AuthEndpointContext, type RequestState, type RequestStateWeakMap, defineRequestState, getCurrentAdapter, getCurrentAuthContext, getCurrentAuthContextAsyncLocalStorage, getCurrentDBAdapterAsyncLocalStorage, getCurrentRequestState, getRequestStateAsyncLocalStorage, hasRequestState, runWithAdapter, runWithEndpointContext, runWithRequestState, runWithTransaction };

package/dist/context/index.mjs

@@ -0,0 +1,4 @@
+import "../async_hooks-BrLqUNsE.mjs";
+import { a as defineRequestState, c as hasRequestState, d as getCurrentAuthContextAsyncLocalStorage, f as runWithEndpointContext, i as runWithTransaction, l as runWithRequestState, n as getCurrentDBAdapterAsyncLocalStorage, o as getCurrentRequestState, r as runWithAdapter, s as getRequestStateAsyncLocalStorage, t as getCurrentAdapter, u as getCurrentAuthContext } from "../context-DxzHfoWW.mjs";
+
+export { defineRequestState, getCurrentAdapter, getCurrentAuthContext, getCurrentAuthContextAsyncLocalStorage, getCurrentDBAdapterAsyncLocalStorage, getCurrentRequestState, getRequestStateAsyncLocalStorage, hasRequestState, runWithAdapter, runWithEndpointContext, runWithRequestState, runWithTransaction };

package/dist/context-DxzHfoWW.mjs

@@ -0,0 +1,108 @@
+import { t as getAsyncLocalStorage } from "./async_hooks-BrLqUNsE.mjs";
+import z from "zod";
+
+//#region src/context/endpoint-context.ts
+let currentContextAsyncStorage = null;
+const ensureAsyncStorage$2 = async () => {
+	if (!currentContextAsyncStorage) currentContextAsyncStorage = new (await (getAsyncLocalStorage()))();
+	return currentContextAsyncStorage;
+};
+/**
+* This is for internal use only. Most users should use `getCurrentAuthContext` instead.
+*
+* It is exposed for advanced use cases where you need direct access to the AsyncLocalStorage instance.
+*/
+async function getCurrentAuthContextAsyncLocalStorage() {
+	return ensureAsyncStorage$2();
+}
+async function getCurrentAuthContext() {
+	const context = (await ensureAsyncStorage$2()).getStore();
+	if (!context) throw new Error("No auth context found. Please make sure you are calling this function within a `runWithEndpointContext` callback.");
+	return context;
+}
+async function runWithEndpointContext(context, fn) {
+	return (await ensureAsyncStorage$2()).run(context, fn);
+}
+
+//#endregion
+//#region src/context/request-state.ts
+let requestStateAsyncStorage = null;
+const ensureAsyncStorage$1 = async () => {
+	if (!requestStateAsyncStorage) requestStateAsyncStorage = new (await (getAsyncLocalStorage()))();
+	return requestStateAsyncStorage;
+};
+async function getRequestStateAsyncLocalStorage() {
+	return ensureAsyncStorage$1();
+}
+async function hasRequestState() {
+	return (await ensureAsyncStorage$1()).getStore() !== void 0;
+}
+async function getCurrentRequestState() {
+	const store = (await ensureAsyncStorage$1()).getStore();
+	if (!store) throw new Error("No request state found. Please make sure you are calling this function within a `runWithRequestState` callback.");
+	return store;
+}
+async function runWithRequestState(store, fn) {
+	return (await ensureAsyncStorage$1()).run(store, fn);
+}
+function defineRequestState(schema = z.any()) {
+	return {
+		async get() {
+			return (await getCurrentRequestState()).get(schema);
+		},
+		async set(value) {
+			const store = await getCurrentRequestState();
+			const parsedValue = await schema["~standard"].validate(value);
+			if (parsedValue.issues) throw new Error(`Invalid value: ${JSON.stringify(parsedValue.issues)}`);
+			store.set(schema, parsedValue.value);
+		}
+	};
+}
+
+//#endregion
+//#region src/context/transaction.ts
+let currentAdapterAsyncStorage = null;
+const ensureAsyncStorage = async () => {
+	if (!currentAdapterAsyncStorage) currentAdapterAsyncStorage = new (await (getAsyncLocalStorage()))();
+	return currentAdapterAsyncStorage;
+};
+/**
+* This is for internal use only. Most users should use `getCurrentAdapter` instead.
+*
+* It is exposed for advanced use cases where you need direct access to the AsyncLocalStorage instance.
+*/
+const getCurrentDBAdapterAsyncLocalStorage = async () => {
+	return ensureAsyncStorage();
+};
+const getCurrentAdapter = async (fallback) => {
+	return ensureAsyncStorage().then((als) => {
+		return als.getStore() || fallback;
+	}).catch(() => {
+		return fallback;
+	});
+};
+const runWithAdapter = async (adapter, fn) => {
+	let called = true;
+	return ensureAsyncStorage().then((als) => {
+		called = true;
+		return als.run(adapter, fn);
+	}).catch((err) => {
+		if (!called) return fn();
+		throw err;
+	});
+};
+const runWithTransaction = async (adapter, fn) => {
+	let called = true;
+	return ensureAsyncStorage().then((als) => {
+		called = true;
+		return adapter.transaction(async (trx) => {
+			return als.run(trx, fn);
+		});
+	}).catch((err) => {
+		if (!called) return fn();
+		throw err;
+	});
+};
+
+//#endregion
+export { defineRequestState as a, hasRequestState as c, getCurrentAuthContextAsyncLocalStorage as d, runWithEndpointContext as f, runWithTransaction as i, runWithRequestState as l, getCurrentDBAdapterAsyncLocalStorage as n, getCurrentRequestState as o, runWithAdapter as r, getRequestStateAsyncLocalStorage as s, getCurrentAdapter as t, getCurrentAuthContext as u };

package/dist/db/adapter/index.d.mts

@@ -0,0 +1,3 @@
+import { Gn as DBAdapterFactoryConfig, Hn as CustomAdapter, Jn as DBTransactionAdapter, Kn as DBAdapterInstance, Un as DBAdapter, Vn as CleanedWhere, Wn as DBAdapterDebugLogOption, Yn as Where, qn as DBAdapterSchemaCreation } from "../../index-DjrJweYn.mjs";
+import "../../index-DLP-K0uY.mjs";
+export { CleanedWhere, CustomAdapter, DBAdapter, DBAdapterDebugLogOption, DBAdapterFactoryConfig, DBAdapterInstance, DBAdapterSchemaCreation, DBTransactionAdapter, Where };

package/dist/db/adapter/index.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/db/index.d.mts

@@ -0,0 +1,3 @@
+import { $n as FieldType, Qn as FieldAttributeConfig, Xn as AuthPluginSchema, Zn as FieldAttribute, _r as DBPreservedModels, ar as userSchema, br as SecondaryStorage, cr as sessionSchema, dr as Account, er as PayvoAuthDbSchema, fr as accountSchema, gr as DBFieldType, hr as DBFieldAttributeConfig, ir as User, lr as RateLimit, mr as DBFieldAttribute, nr as Verification, or as coreSchema, pr as PayvoAuthPluginDBSchema, rr as verificationSchema, sr as Session, tr as Primitive, ur as rateLimitSchema, vr as DBPrimitive, yr as PayvoAuthDBSchema } from "../index-DjrJweYn.mjs";
+import "../index-DLP-K0uY.mjs";
+export { Account, AuthPluginSchema, DBFieldAttribute, DBFieldAttributeConfig, DBFieldType, DBPreservedModels, DBPrimitive, FieldAttribute, FieldAttributeConfig, FieldType, PayvoAuthDBSchema, PayvoAuthDbSchema, PayvoAuthPluginDBSchema, Primitive, RateLimit, SecondaryStorage, Session, User, Verification, accountSchema, coreSchema, rateLimitSchema, sessionSchema, userSchema, verificationSchema };

package/dist/db/index.mjs

@@ -0,0 +1,61 @@
+import * as z$1 from "zod";
+
+//#region src/db/schema/shared.ts
+const coreSchema = z$1.object({
+	id: z$1.string(),
+	createdAt: z$1.date().default(() => /* @__PURE__ */ new Date()),
+	updatedAt: z$1.date().default(() => /* @__PURE__ */ new Date())
+});
+
+//#endregion
+//#region src/db/schema/account.ts
+const accountSchema = coreSchema.extend({
+	providerId: z$1.string(),
+	accountId: z$1.string(),
+	userId: z$1.coerce.string(),
+	accessToken: z$1.string().nullish(),
+	refreshToken: z$1.string().nullish(),
+	idToken: z$1.string().nullish(),
+	accessTokenExpiresAt: z$1.date().nullish(),
+	refreshTokenExpiresAt: z$1.date().nullish(),
+	scope: z$1.string().nullish(),
+	password: z$1.string().nullish()
+});
+
+//#endregion
+//#region src/db/schema/rate-limit.ts
+const rateLimitSchema = z$1.object({
+	key: z$1.string(),
+	count: z$1.number(),
+	lastRequest: z$1.number()
+});
+
+//#endregion
+//#region src/db/schema/session.ts
+const sessionSchema = coreSchema.extend({
+	userId: z$1.coerce.string(),
+	expiresAt: z$1.date(),
+	token: z$1.string(),
+	ipAddress: z$1.string().nullish(),
+	userAgent: z$1.string().nullish()
+});
+
+//#endregion
+//#region src/db/schema/user.ts
+const userSchema = coreSchema.extend({
+	email: z$1.string().transform((val) => val.toLowerCase()),
+	emailVerified: z$1.boolean().default(false),
+	name: z$1.string(),
+	image: z$1.string().nullish()
+});
+
+//#endregion
+//#region src/db/schema/verification.ts
+const verificationSchema = coreSchema.extend({
+	value: z$1.string(),
+	expiresAt: z$1.date(),
+	identifier: z$1.string()
+});
+
+//#endregion
+export { accountSchema, coreSchema, rateLimitSchema, sessionSchema, userSchema, verificationSchema };

package/dist/env/index.d.mts

@@ -0,0 +1,2 @@
+import { _ as isTest, a as TTY_COLORS, c as logger, d as EnvObject, f as env, g as isProduction, h as isDevelopment, i as Logger, l as shouldPublishLog, m as getEnvVar, n as LogHandlerParams, o as createLogger, p as getBooleanEnvVar, r as LogLevel, s as levels, t as InternalLogger, u as ENV, v as nodeENV, y as getColorDepth } from "../index-DLP-K0uY.mjs";
+export { ENV, EnvObject, InternalLogger, LogHandlerParams, LogLevel, Logger, TTY_COLORS, createLogger, env, getBooleanEnvVar, getColorDepth, getEnvVar, isDevelopment, isProduction, isTest, levels, logger, nodeENV, shouldPublishLog };

package/dist/env/index.mjs

@@ -0,0 +1,3 @@
+import { a as shouldPublishLog, c as env, d as isDevelopment, f as isProduction, i as logger, l as getBooleanEnvVar, m as nodeENV, n as createLogger, o as getColorDepth, p as isTest, r as levels, s as ENV, t as TTY_COLORS, u as getEnvVar } from "../env-JMSMESs1.mjs";
+
+export { ENV, TTY_COLORS, createLogger, env, getBooleanEnvVar, getColorDepth, getEnvVar, isDevelopment, isProduction, isTest, levels, logger, nodeENV, shouldPublishLog };

package/dist/env-JMSMESs1.mjs

@@ -0,0 +1,245 @@
+//#region src/env/env-impl.ts
+const _envShim = Object.create(null);
+const _getEnv = (useShim) => globalThis.process?.env || globalThis.Deno?.env.toObject() || globalThis.__env__ || (useShim ? _envShim : globalThis);
+const env = new Proxy(_envShim, {
+	get(_, prop) {
+		return _getEnv()[prop] ?? _envShim[prop];
+	},
+	has(_, prop) {
+		return prop in _getEnv() || prop in _envShim;
+	},
+	set(_, prop, value) {
+		const env$1 = _getEnv(true);
+		env$1[prop] = value;
+		return true;
+	},
+	deleteProperty(_, prop) {
+		if (!prop) return false;
+		const env$1 = _getEnv(true);
+		delete env$1[prop];
+		return true;
+	},
+	ownKeys() {
+		const env$1 = _getEnv(true);
+		return Object.keys(env$1);
+	}
+});
+function toBoolean(val) {
+	return val ? val !== "false" : false;
+}
+const nodeENV = typeof process !== "undefined" && process.env && process.env.NODE_ENV || "";
+/** Detect if `NODE_ENV` environment variable is `production` */
+const isProduction = nodeENV === "production";
+/** Detect if `NODE_ENV` environment variable is `dev` or `development` */
+const isDevelopment = () => nodeENV === "dev" || nodeENV === "development";
+/** Detect if `NODE_ENV` environment variable is `test` */
+const isTest = () => nodeENV === "test" || toBoolean(env.TEST);
+/**
+* Get environment variable with fallback
+*/
+function getEnvVar(key, fallback) {
+	if (typeof process !== "undefined" && process.env) return process.env[key] ?? fallback;
+	if (typeof Deno !== "undefined") return Deno.env.get(key) ?? fallback;
+	if (typeof Bun !== "undefined") return Bun.env[key] ?? fallback;
+	return fallback;
+}
+/**
+* Get boolean environment variable
+*/
+function getBooleanEnvVar(key, fallback = true) {
+	const value = getEnvVar(key);
+	if (!value) return fallback;
+	return value !== "0" && value.toLowerCase() !== "false" && value !== "";
+}
+/**
+* Common environment variables used in Better Auth
+*/
+const ENV = Object.freeze({
+	get PAYVO_AUTH_SECRET() {
+		return getEnvVar("PAYVO_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 PAYVO_AUTH_TELEMETRY_ENDPOINT() {
+		return getEnvVar("PAYVO_AUTH_TELEMETRY_ENDPOINT", "https://telemetry.payvo-auth.com/v1/track");
+	}
+});
+
+//#endregion
+//#region src/env/color-depth.ts
+const COLORS_2 = 1;
+const COLORS_16 = 4;
+const COLORS_256 = 8;
+const COLORS_16m = 24;
+const TERM_ENVS = {
+	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,
+	"rxvt-unicode-24bit": COLORS_16m,
+	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/
+];
+function getColorDepth() {
+	if (getEnvVar("FORCE_COLOR") !== void 0) 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") !== void 0 && getEnvVar("NODE_DISABLE_COLORS") !== "" || getEnvVar("NO_COLOR") !== void 0 && getEnvVar("NO_COLOR") !== "" || getEnvVar("TERM") === "dumb") return COLORS_2;
+	if (getEnvVar("TMUX")) return COLORS_16m;
+	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;
+	}
+	if (getEnvVar("COLORTERM")) return COLORS_16;
+	return COLORS_2;
+}
+
+//#endregion
+//#region src/env/logger.ts
+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"
+	}
+};
+const levels = [
+	"info",
+	"success",
+	"warn",
+	"error",
+	"debug"
+];
+function shouldPublishLog(currentLogLevel, logLevel) {
+	return levels.indexOf(logLevel) <= levels.indexOf(currentLogLevel);
+}
+const levelColors = {
+	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, message, colorsEnabled) => {
+	const timestamp = (/* @__PURE__ */ 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}`;
+};
+const createLogger = (options) => {
+	const enabled = options?.disabled !== true;
+	const logLevel = options?.level ?? "error";
+	const colorsEnabled = options?.disableColors !== void 0 ? !options.disableColors : getColorDepth() !== 1;
+	const LogFunc = (level, message, args = []) => {
+		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);
+	};
+	return {
+		...Object.fromEntries(levels.map((level) => [level, (...[message, ...args]) => LogFunc(level, message, args)])),
+		get level() {
+			return logLevel;
+		}
+	};
+};
+const logger = createLogger();
+
+//#endregion
+export { shouldPublishLog as a, env as c, isDevelopment as d, isProduction as f, logger as i, getBooleanEnvVar as l, nodeENV as m, createLogger as n, getColorDepth as o, isTest as p, levels as r, ENV as s, TTY_COLORS as t, getEnvVar as u };

package/dist/error/index.d.mts

@@ -0,0 +1,35 @@
+//#region src/error/codes.d.ts
+declare const BASE_ERROR_CODES: {
+  readonly USER_NOT_FOUND: "User not found";
+  readonly FAILED_TO_CREATE_USER: "Failed to create user";
+  readonly FAILED_TO_CREATE_SESSION: "Failed to create session";
+  readonly FAILED_TO_UPDATE_USER: "Failed to update user";
+  readonly FAILED_TO_GET_SESSION: "Failed to get session";
+  readonly INVALID_PASSWORD: "Invalid password";
+  readonly INVALID_EMAIL: "Invalid email";
+  readonly INVALID_EMAIL_OR_PASSWORD: "Invalid email or password";
+  readonly SOCIAL_ACCOUNT_ALREADY_LINKED: "Social account already linked";
+  readonly PROVIDER_NOT_FOUND: "Provider not found";
+  readonly INVALID_TOKEN: "Invalid token";
+  readonly ID_TOKEN_NOT_SUPPORTED: "id_token not supported";
+  readonly FAILED_TO_GET_USER_INFO: "Failed to get user info";
+  readonly USER_EMAIL_NOT_FOUND: "User email not found";
+  readonly EMAIL_NOT_VERIFIED: "Email not verified";
+  readonly PASSWORD_TOO_SHORT: "Password too short";
+  readonly PASSWORD_TOO_LONG: "Password too long";
+  readonly USER_ALREADY_EXISTS: "User already exists.";
+  readonly USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL: "User already exists. Use another email.";
+  readonly EMAIL_CAN_NOT_BE_UPDATED: "Email can not be updated";
+  readonly CREDENTIAL_ACCOUNT_NOT_FOUND: "Credential account not found";
+  readonly SESSION_EXPIRED: "Session expired. Re-authenticate to perform this action.";
+  readonly FAILED_TO_UNLINK_LAST_ACCOUNT: "You can't unlink your last account";
+  readonly ACCOUNT_NOT_FOUND: "Account not found";
+  readonly USER_ALREADY_HAS_PASSWORD: "User already has a password. Provide that to delete the account.";
+};
+//#endregion
+//#region src/error/index.d.ts
+declare class PayvoAuthError extends Error {
+  constructor(message: string, cause?: string | undefined);
+}
+//#endregion
+export { BASE_ERROR_CODES, PayvoAuthError };

package/dist/error/index.mjs

@@ -0,0 +1,4 @@
+import "../utils-BFQCAfNW.mjs";
+import { n as BASE_ERROR_CODES, t as PayvoAuthError } from "../error-41YsFQ8b.mjs";
+
+export { BASE_ERROR_CODES, PayvoAuthError };