pecunia-core 0.0.0

package/dist/api/index.d.mts

@@ -0,0 +1,2 @@
+import { a as useMiddleware, i as optionsMiddleware, n as createPaymentEndpoint, r as createPecuniaMiddleware, t as PaymentMiddleware } from "../index-CtOgkCz5.mjs";
+export { PaymentMiddleware, createPaymentEndpoint, createPecuniaMiddleware, optionsMiddleware, useMiddleware };

package/dist/api/index.mjs

@@ -0,0 +1,5 @@
+import "../context-_erD9NsC.mjs";
+import "../async_hooks-D8vqDJIk.mjs";
+import { i as useMiddleware, n as createPecuniaMiddleware, r as optionsMiddleware, t as createPaymentEndpoint } from "../api-Dnub-EIf.mjs";
+
+export { createPaymentEndpoint, createPecuniaMiddleware, optionsMiddleware, useMiddleware };

package/dist/api-Dnub-EIf.mjs

@@ -0,0 +1,35 @@
+import { f as runWithEndpointContext } from "./context-_erD9NsC.mjs";
+import { createEndpoint, createMiddleware } from "better-call";
+
+//#region src/api/middleware/index.ts
+const optionsMiddleware = createMiddleware(async () => {
+	/**
+	* This will be passed on the instance of
+	* the context. Used to infer the type
+	* here.
+	*/
+	return {};
+});
+const createPecuniaMiddleware = createMiddleware.create({ use: [optionsMiddleware, createMiddleware(async () => {
+	return {};
+})] });
+const useMiddleware = [optionsMiddleware];
+
+//#endregion
+//#region src/api/endpoint/index.ts
+function createPaymentEndpoint(pathOrOptions, handlerOrOptions, handlerOrNever) {
+	const path = typeof pathOrOptions === "string" ? pathOrOptions : void 0;
+	const options = typeof handlerOrOptions === "object" ? handlerOrOptions : pathOrOptions;
+	const handler = typeof handlerOrOptions === "function" ? handlerOrOptions : handlerOrNever;
+	if (path) return createEndpoint(path, {
+		...options,
+		use: [...options?.use || [], ...useMiddleware]
+	}, async (ctx) => runWithEndpointContext(ctx, () => handler(ctx)));
+	return createEndpoint({
+		...options,
+		use: [...options?.use || [], ...useMiddleware]
+	}, async (ctx) => runWithEndpointContext(ctx, () => handler(ctx)));
+}
+
+//#endregion
+export { useMiddleware as i, createPecuniaMiddleware as n, optionsMiddleware as r, createPaymentEndpoint as t };

package/dist/async_hooks-D8vqDJIk.mjs

@@ -0,0 +1,20 @@
+//#region src/hooks/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;
+	if (typeof window !== "undefined") return null;
+	console.warn("[senly] Warning: AsyncLocalStorage is not available in this environment. Some features may not work as expected.");
+	console.warn("[senly] If you are using Cloudflare Workers, please see: https://developers.cloudflare.com/workers/configuration/compatibility-flags/#nodejs-compatibility-flag");
+	throw err;
+});
+async function getAsyncLocalStorage() {
+	const mod = await AsyncLocalStoragePromise;
+	if (mod === null) throw new Error("getAsyncLocalStorage is only available in server code");
+	else return mod;
+}
+
+//#endregion
+export { getAsyncLocalStorage as t };

package/dist/context/index.d.mts

@@ -0,0 +1,2 @@
+import { At as RequestState, Dt as getCurrentDBAdapterAsyncLocalStorage, Et as getCurrentAdapter, Ft as hasRequestState, It as runWithRequestState, Lt as getCurrentAuthContext, Mt as defineRequestState, Nt as getCurrentRequestState, Ot as runWithAdapter, Pt as getRequestStateAsyncLocalStorage, Rt as getCurrentPaymentContextAsyncLocalStorage, jt as RequestStateWeakMap, kt as runWithTransaction, zt as runWithEndpointContext } from "../index-CtOgkCz5.mjs";
+export { RequestState, RequestStateWeakMap, defineRequestState, getCurrentAdapter, getCurrentAuthContext, getCurrentDBAdapterAsyncLocalStorage, getCurrentPaymentContextAsyncLocalStorage, getCurrentRequestState, getRequestStateAsyncLocalStorage, hasRequestState, runWithAdapter, runWithEndpointContext, runWithRequestState, runWithTransaction };

package/dist/context/index.mjs

@@ -0,0 +1,4 @@
+import { a as defineRequestState, c as hasRequestState, d as getCurrentPaymentContextAsyncLocalStorage, 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-_erD9NsC.mjs";
+import "../async_hooks-D8vqDJIk.mjs";
+
+export { defineRequestState, getCurrentAdapter, getCurrentAuthContext, getCurrentDBAdapterAsyncLocalStorage, getCurrentPaymentContextAsyncLocalStorage, getCurrentRequestState, getRequestStateAsyncLocalStorage, hasRequestState, runWithAdapter, runWithEndpointContext, runWithRequestState, runWithTransaction };

package/dist/context-_erD9NsC.mjs

@@ -0,0 +1,164 @@
+import { t as getAsyncLocalStorage } from "./async_hooks-D8vqDJIk.mjs";
+
+//#region src/hooks/async_hooks/pure.ts
+/**
+* Polyfill for serverless functions.
+*/
+var AsyncLocalStoragePolyfill = class {
+	#current = void 0;
+	run(store, fn) {
+		const prev = this.#current;
+		this.#current = store;
+		const result = fn();
+		if (result instanceof Promise) return result.finally(() => {
+			this.#current = prev;
+		});
+		this.#current = prev;
+		return result;
+	}
+	getStore() {
+		return this.#current;
+	}
+};
+const AsyncLocalStoragePromise = Promise.resolve().then(() => {
+	if ("AsyncLocalStorage" in globalThis) return globalThis.AsyncLocalStorage;
+	return AsyncLocalStoragePolyfill;
+});
+async function getAsyncLocalStorage$1() {
+	const mod = await AsyncLocalStoragePromise;
+	if (mod === null) throw new Error("getAsyncLocalStorage is only available in server code");
+	else return mod;
+}
+
+//#endregion
+//#region src/context/payment-context.ts
+let currentContextAsyncStorage = null;
+const ensureAsyncStorage$2 = async () => {
+	if (!currentContextAsyncStorage) currentContextAsyncStorage = new (await (getAsyncLocalStorage$1()))();
+	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 getCurrentPaymentContextAsyncLocalStorage() {
+	return ensureAsyncStorage$2();
+}
+async function getCurrentAuthContext() {
+	const context = (await ensureAsyncStorage$2()).getStore();
+	if (!context) throw new Error("No payment 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$1()))();
+	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(initFn) {
+	const ref = Object.freeze({});
+	return {
+		get ref() {
+			return ref;
+		},
+		async get() {
+			const store = await getCurrentRequestState();
+			if (!store.has(ref)) {
+				const initialValue = await initFn();
+				store.set(ref, initialValue);
+				return initialValue;
+			}
+			return store.get(ref);
+		},
+		async set(value) {
+			(await getCurrentRequestState()).set(ref, 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
+//#region src/context/index.ts
+const glo = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {};
+const importIdentifier = "__ $PECUNIA$ __";
+if (glo[importIdentifier] === true)
+ /**
+* Dear reader of this message. Please take this seriously.
+*
+* If you see this message, make sure that you only import one version of Pecunia. In many cases,
+* your package manager installs two versions of Pecunia that are used by different packages within your project.
+*
+* This often leads to issues that are hard to debug. We often need to ensure async local storage instance,
+* If you imported different versions of Pecunia, it is impossible for us to
+* do status synchronization per request anymore - which might break the states.
+*
+*/
+console.error("Pecunia was already imported. This breaks async local storage instance and will lead to issues!");
+glo[importIdentifier] = true;
+
+//#endregion
+export { defineRequestState as a, hasRequestState as c, getCurrentPaymentContextAsyncLocalStorage 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/index.d.mts

@@ -0,0 +1,2 @@
+import { $t as KyselyDatabaseDialectType, Ct as initGetFieldAttributes, St as initGetFieldName, Tt as initGetDefaultFieldName, _t as discountSchema, at as getPaymentTables, bt as initGetModelName, ct as Subscription, dt as sharedDeletableSchema, ft as Product, gt as Discount, ht as priceSchema, lt as subscriptionSchema, mt as Price, ot as deepmerge, pt as productSchema, st as withApplyDefault, ut as sharedCoreSchema, vt as Customer, wt as initGetDefaultModelName, xt as initGetIdField, yt as customerSchema } from "../index-CtOgkCz5.mjs";
+export { Customer, Discount, KyselyDatabaseDialectType, Price, Product, Subscription, customerSchema, deepmerge, discountSchema, getPaymentTables, initGetDefaultFieldName, initGetDefaultModelName, initGetFieldAttributes, initGetFieldName, initGetIdField, initGetModelName, priceSchema, productSchema, sharedCoreSchema, sharedDeletableSchema, subscriptionSchema, withApplyDefault };

package/dist/db/index.mjs

@@ -0,0 +1,6 @@
+import "../errors-vpD21Iku.mjs";
+import { a as initGetFieldAttributes, c as initGetDefaultModelName, i as initGetModelName, n as deepmerge, o as initGetIdField, r as withApplyDefault, s as initGetDefaultFieldName, t as getPaymentTables } from "../get-payment-tables-0FkEj3dw.mjs";
+import "../generate-id-D3ZvbbXn.mjs";
+import { a as customerSchema, c as initGetFieldName, i as discountSchema, n as productSchema, o as sharedCoreSchema, r as priceSchema, s as sharedDeletableSchema, t as subscriptionSchema } from "../db-JBwMpkmd.mjs";
+
+export { customerSchema, deepmerge, discountSchema, getPaymentTables, initGetDefaultFieldName, initGetDefaultModelName, initGetFieldAttributes, initGetFieldName, initGetIdField, initGetModelName, priceSchema, productSchema, sharedCoreSchema, sharedDeletableSchema, subscriptionSchema, withApplyDefault };

package/dist/db-JBwMpkmd.mjs

@@ -0,0 +1,146 @@
+import { A as UsageAggregation, E as SubscriptionStatus, S as ProrationBehavior, b as PricingModel, c as BillingInterval, d as CollectionMethod, f as Currency, p as DiscountType, x as ProductType, y as PriceType } from "./errors-vpD21Iku.mjs";
+import { c as initGetDefaultModelName, s as initGetDefaultFieldName } from "./get-payment-tables-0FkEj3dw.mjs";
+import z$1, { z } from "zod";
+
+//#region src/db/attributes/get-field-name.ts
+const initGetFieldName = ({ schema, usePlural }) => {
+	const getDefaultModelName = initGetDefaultModelName({
+		schema,
+		usePlural
+	});
+	const getDefaultFieldName = initGetDefaultFieldName({
+		schema,
+		usePlural
+	});
+	/**
+	* Get the field name which is expected to be saved in the database based on the user's schema.
+	*
+	* This function is useful if you need to save the field name to the database.
+	*
+	* For example, if the user has defined a custom field name for the `user` model, then you can use this function to get the actual field name from the schema.
+	*/
+	function getFieldName({ model: modelName, field: fieldName }) {
+		const model = getDefaultModelName(modelName);
+		const field = getDefaultFieldName({
+			model,
+			field: fieldName
+		});
+		return schema[model]?.fields[field]?.fieldName || field;
+	}
+	return getFieldName;
+};
+
+//#endregion
+//#region src/db/schema/shared.ts
+const sharedCoreSchema = z$1.object({
+	id: z$1.uuid("id"),
+	createdAt: z$1.date().default(() => /* @__PURE__ */ new Date()),
+	updatedAt: z$1.date().default(() => /* @__PURE__ */ new Date())
+});
+const sharedDeletableSchema = z$1.object({
+	deleted: z$1.boolean().default(false),
+	deletedAt: z$1.coerce.date().optional()
+});
+
+//#endregion
+//#region src/db/schema/customer.ts
+const customerSchema = sharedCoreSchema.extend({
+	phoneNumber: z$1.string().max(15),
+	firstName: z$1.string().max(50),
+	paymentMethodId: z$1.string().optional(),
+	lastName: z$1.string().max(50),
+	email: z$1.email().max(255)
+});
+
+//#endregion
+//#region src/db/schema/discount.ts
+const discountSchema = sharedCoreSchema.extend(sharedDeletableSchema.shape).extend({
+	code: z.string().max(50),
+	name: z.string().max(255).optional(),
+	description: z.string().optional(),
+	type: z.enum(DiscountType).default(DiscountType.PERCENTAGE),
+	value: z.number().positive().min(0),
+	currency: z.enum(Currency).optional(),
+	active: z.boolean().default(true),
+	startsAt: z.coerce.date().optional(),
+	endsAt: z.coerce.date().optional(),
+	maxUses: z.number().int().positive().optional(),
+	maxUsesPerCustomer: z.number().int().positive().optional(),
+	timesUsed: z.number().int().nonnegative().default(0),
+	minimumAmount: z.number().positive().optional(),
+	minimumAmountCurrency: z.enum(Currency).optional(),
+	maximumDiscountAmount: z.number().positive().optional(),
+	maximumDiscountAmountCurrency: z.enum(Currency).optional(),
+	durationInMonths: z.number().int().positive().optional(),
+	appliesToProductIds: z.array(z.uuid()).default([]),
+	appliesToPriceIds: z.array(z.uuid()).default([]),
+	appliesToCustomerIds: z.array(z.uuid()).default([]),
+	appliesToAllProducts: z.boolean().default(false),
+	appliesToAllPrices: z.boolean().default(false),
+	appliesToAllCustomers: z.boolean().default(true),
+	firstTimeCustomerOnly: z.boolean().default(false),
+	metadata: z.record(z.string(), z.union([z.string(), z.number()])).optional()
+});
+
+//#endregion
+//#region src/db/schema/price.ts
+const priceSchema = sharedCoreSchema.extend(sharedDeletableSchema.shape).extend({
+	productId: z.uuid().optional(),
+	unitAmount: z.number().default(0),
+	currency: z.enum(Currency).default(Currency.KES),
+	type: z.enum(PriceType).default(PriceType.ONE_TIME),
+	pricingModel: z.enum(PricingModel).default(PricingModel.FLAT),
+	billingInterval: z.enum(BillingInterval).default(BillingInterval.MONTH),
+	billingIntervalCount: z.number().min(1).default(1),
+	trialPeriodDays: z.number().min(0).default(0),
+	usageAggregation: z.enum(UsageAggregation).optional(),
+	active: z.boolean().default(true),
+	metadata: z.record(z.string(), z.union([z.string(), z.number()])).optional()
+});
+
+//#endregion
+//#region src/db/schema/product.ts
+const productSchema = sharedCoreSchema.extend(sharedDeletableSchema.shape).extend({
+	type: z$1.enum(ProductType),
+	name: z$1.string().max(255),
+	description: z$1.string().optional(),
+	images: z$1.array(z$1.string()).default([]),
+	defaultPriceId: z$1.uuid().optional(),
+	marketing_features: z$1.array(z$1.object({ name: z$1.string() })).optional(),
+	package_dimensions: z$1.object({
+		height: z$1.number(),
+		length: z$1.number(),
+		weight: z$1.number(),
+		width: z$1.number()
+	}).optional(),
+	shippable: z$1.boolean().optional(),
+	url: z$1.url().optional(),
+	active: z$1.boolean().default(true),
+	metadata: z$1.record(z$1.string(), z$1.union([z$1.string(), z$1.number()])).optional()
+});
+
+//#endregion
+//#region src/db/schema/subscription.ts
+const subscriptionSchema = sharedCoreSchema.extend(sharedDeletableSchema.shape).extend({
+	customerId: z.uuid(),
+	paymentMethodId: z.uuid().optional(),
+	discountId: z.uuid().optional(),
+	discountEndsAt: z.coerce.date().optional(),
+	status: z.enum(SubscriptionStatus).default(SubscriptionStatus.INCOMPLETE),
+	currentBillingPeriodStart: z.coerce.date(),
+	currentBillingPeriodEnd: z.coerce.date(),
+	currentTrialStart: z.coerce.date().optional(),
+	currentTrialEnd: z.coerce.date().optional(),
+	cancelAtPeriodEnd: z.boolean().default(false),
+	canceledAt: z.coerce.date().optional(),
+	cancelAt: z.coerce.date().optional(),
+	daysUntilDue: z.number().min(0).default(0),
+	proration: z.enum(ProrationBehavior).default(ProrationBehavior.CREATE_PRORATIONS),
+	collectionMethod: z.enum(CollectionMethod).default(CollectionMethod.SEND_INVOICE),
+	metadata: z.record(z.string(), z.union([z.string(), z.number()])).optional(),
+	subscriptionStartedAt: z.coerce.date(),
+	subscriptionEndedAt: z.coerce.date().optional()
+});
+
+//#endregion
+export { customerSchema as a, initGetFieldName as c, discountSchema as i, productSchema as n, sharedCoreSchema as o, priceSchema as r, sharedDeletableSchema as s, subscriptionSchema as t };

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-B_V7jOck.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-C7DHqPmD.mjs";
+
+export { ENV, TTY_COLORS, createLogger, env, getBooleanEnvVar, getColorDepth, getEnvVar, isDevelopment, isProduction, isTest, levels, logger, nodeENV, shouldPublishLog };

package/dist/env-C7DHqPmD.mjs

@@ -0,0 +1,230 @@
+//#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 Pecunia
+*/
+const ENV = Object.freeze({
+	get NODE_ENV() {
+		return getEnvVar("NODE_ENV", "development");
+	},
+	get PACKAGE_VERSION() {
+		return getEnvVar("PACKAGE_VERSION", "0.0.0");
+	}
+});
+
+//#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 = [
+	"debug",
+	"info",
+	"success",
+	"warn",
+	"error"
+];
+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/errors/index.d.mts

@@ -0,0 +1,2 @@
+import { it as createProviderError, nt as PecuniaError, rt as ValidationError, tt as ApiError } from "../index-CtOgkCz5.mjs";
+export { ApiError, PecuniaError, ValidationError, createProviderError };

package/dist/errors/index.mjs

@@ -0,0 +1,3 @@
+import { i as createProviderError, n as PecuniaError, r as ValidationError, t as ApiError } from "../errors-vpD21Iku.mjs";
+
+export { ApiError, PecuniaError, ValidationError, createProviderError };