faire-auth 1.0.0

package/dist/cookies-Ch1JfQIz.mjs

@@ -0,0 +1,367 @@
+import { n as __export, r as __reExport } from "./chunk-Ceigfy4P.mjs";
+import { n as crypto_exports } from "./crypto-CyQRFtkq.mjs";
+import { t as safeJSONParse } from "./json-B1v2qRTQ.mjs";
+import { env, isProduction } from "@faire-auth/core/env";
+import { FaireAuthError } from "@faire-auth/core/error";
+import { isPromise } from "@faire-auth/core/static";
+import { createTime, getDate } from "@faire-auth/core/utils";
+import { base64Url, binary, createHMAC } from "@faire-auth/core/datatypes";
+import * as hc from "hono/cookie";
+import { parse, parseSigned, serialize as serialize$1, serializeSigned } from "hono/utils/cookie";
+
+//#region src/utils/cookies.ts
+var cookies_exports = /* @__PURE__ */ __export({
+	checkAuthCookie: () => checkAuthCookie,
+	createCookieCapture: () => createCookieCapture,
+	createCookieCreator: () => createCookieCreator,
+	createCookieSetter: () => createCookieSetter,
+	deleteSessionCookie: () => deleteSessionCookie,
+	getCookieCache: () => getCookieCache,
+	getCookieKey: () => getCookieKey,
+	getCookies: () => getCookies,
+	getSessionCookie: () => getSessionCookie,
+	parse: () => parse,
+	parseCookies: () => parseCookies,
+	parseSetCookieHeader: () => parseSetCookieHeader,
+	parseSigned: () => parseSigned,
+	serialize: () => serialize$1,
+	serializeSigned: () => serializeSigned,
+	serializeSignedCookie: () => serializeSignedCookie,
+	setCookieCache: () => setCookieCache,
+	setSessionCookie: () => setSessionCookie
+});
+import * as import_hono_cookie from "hono/cookie";
+__reExport(cookies_exports, import_hono_cookie);
+const tryDecode = (str) => {
+	try {
+		return str.includes("%") ? decodeURIComponent(str) : str;
+	} catch {
+		return str;
+	}
+};
+const getCookieKey = (key, prefix) => {
+	let finalKey = key;
+	if (prefix) if (prefix === "secure") finalKey = `__Secure-${key}`;
+	else if (prefix === "host") finalKey = `__Host-${key}`;
+	else return;
+	return finalKey;
+};
+/**
+* Parse an HTTP Cookie header string and returning an object of all cookie
+* name-value pairs.
+*
+* Inspired by https://github.com/unjs/cookie-es/blob/main/src/cookie/parse.ts
+*
+* @param str the string representing a `Cookie` header value
+*/
+const parseCookies = (str) => {
+	if (typeof str !== "string") throw new TypeError("argument str must be a string");
+	const cookies = /* @__PURE__ */ new Map();
+	let index = 0;
+	while (index < str.length) {
+		const eqIdx = str.indexOf("=", index);
+		if (eqIdx === -1) break;
+		let endIdx = str.indexOf(";", index);
+		if (endIdx === -1) endIdx = str.length;
+		else if (endIdx < eqIdx) {
+			index = str.lastIndexOf(";", eqIdx - 1) + 1;
+			continue;
+		}
+		const key = str.slice(index, eqIdx).trim();
+		if (!cookies.has(key)) {
+			let val = str.slice(eqIdx + 1, endIdx).trim();
+			if (val.codePointAt(0) === 34) val = val.slice(1, -1);
+			cookies.set(key, tryDecode(val));
+		}
+		index = endIdx + 1;
+	}
+	return cookies;
+};
+const _serialize = (key, value, opt = {}) => {
+	let cookie;
+	if (opt.prefix === "secure") cookie = `__Secure-${key}=${value}`;
+	else if (opt.prefix === "host") cookie = `__Host-${key}=${value}`;
+	else cookie = `${key}=${value}`;
+	if (key.startsWith("__Secure-") && !(opt.secure ?? false)) opt.secure = true;
+	if (key.startsWith("__Host-")) {
+		if (!(opt.secure ?? false)) opt.secure = true;
+		if (opt.path !== "/") opt.path = "/";
+		if (opt.domain != null) delete opt.domain;
+	}
+	if (opt != null && typeof opt.maxAge === "number" && opt.maxAge >= 0) {
+		if (opt.maxAge > 3456e4) throw new Error("Cookies Max-Age SHOULD NOT be greater than 400 days (34560000 seconds) in duration.");
+		cookie += `; Max-Age=${Math.floor(opt.maxAge)}`;
+	}
+	if (opt.domain != null && opt.prefix !== "host") cookie += `; Domain=${opt.domain}`;
+	if (opt.path != null) cookie += `; Path=${opt.path}`;
+	if (opt.expires) {
+		if (opt.expires.getTime() - Date.now() > 3456e7) throw new Error("Cookies Expires SHOULD NOT be greater than 400 days (34560000 seconds) in the future.");
+		cookie += `; Expires=${opt.expires.toUTCString()}`;
+	}
+	if (opt.httpOnly === true) cookie += "; HttpOnly";
+	if (opt.secure === true) cookie += "; Secure";
+	if (opt.sameSite) cookie += `; SameSite=${opt.sameSite.charAt(0).toUpperCase() + opt.sameSite.slice(1)}`;
+	if (opt.partitioned === true) {
+		if (!(opt.secure ?? false)) opt.secure = true;
+		cookie += "; Partitioned";
+	}
+	return cookie;
+};
+const serializeSignedCookie = async (key, value, secret, opt) => {
+	value = await (0, crypto_exports.signCookieValue)(value, secret);
+	return _serialize(key, value, opt);
+};
+const checkAuthCookie = async (request, auth) => {
+	const cookies = (request instanceof Headers ? request : request.headers).get("cookie");
+	if (cookies == null) return null;
+	const cookieName = (isPromise(auth.$context) ? await auth.$context : auth.$context).authCookies.sessionToken.name;
+	const sessionToken = parseCookies(cookies).get(cookieName);
+	if (sessionToken != null) return sessionToken;
+	return null;
+};
+/**
+* Split attributes by semicolon, but respect that semicolons
+* might appear in attribute values (though this is rare in practice)
+*/
+const splitAttributes = (str) => {
+	const attributes = [];
+	let current = "";
+	let inQuotes = false;
+	for (let i = 0; i < str.length; i++) {
+		const char = str[i];
+		if (char === "\"" && (i === 0 || str[i - 1] !== "\\")) {
+			inQuotes = !inQuotes;
+			current += char;
+		} else if (char === ";" && !inQuotes) {
+			if (current.trim()) attributes.push(current.trim());
+			current = "";
+		} else current += char;
+	}
+	if (current.trim()) attributes.push(current.trim());
+	return attributes;
+};
+/**
+* IMPORTANT - each Set-Cookie header should be a single cookie
+*/
+const parseSetCookieHeader = (setCookie) => {
+	if (Array.isArray(setCookie)) return new Map(setCookie.flatMap((c) => [...parseSetCookieHeader(c)]));
+	const cookies = /* @__PURE__ */ new Map();
+	const nameValueMatch = setCookie.match(/^([^=]+)=([^;]*)/);
+	if (!nameValueMatch) return cookies;
+	const name = nameValueMatch[1]?.trim();
+	let value = nameValueMatch[2]?.trim() || "";
+	if (!name) return cookies;
+	if (value.startsWith("\"") && value.endsWith("\"") && value.length >= 2) {
+		value = value.slice(1, -1);
+		value = value.replace(/\\"/g, "\"");
+	}
+	const attrObj = { value };
+	const firstSemicolon = setCookie.indexOf(";", nameValueMatch[0].length);
+	if (firstSemicolon === -1) {
+		cookies.set(name, attrObj);
+		return cookies;
+	}
+	splitAttributes(setCookie.slice(firstSemicolon + 1)).forEach((attribute) => {
+		const eqIndex = attribute.indexOf("=");
+		const attrName = eqIndex === -1 ? attribute.trim() : attribute.slice(0, eqIndex).trim();
+		const attrValue = eqIndex === -1 ? "" : attribute.slice(eqIndex + 1).trim();
+		const normalizedAttrName = attrName.toLowerCase();
+		switch (normalizedAttrName) {
+			case "max-age": {
+				const maxAge = attrValue ? Number.parseInt(attrValue, 10) : void 0;
+				if (!Number.isNaN(maxAge) && maxAge != null) attrObj["max-age"] = maxAge;
+				break;
+			}
+			case "expires": {
+				const expires = attrValue ? new Date(attrValue) : void 0;
+				if (expires && !Number.isNaN(expires.getTime())) attrObj.expires = expires;
+				break;
+			}
+			case "domain":
+				if (attrValue) attrObj.domain = attrValue;
+				break;
+			case "path":
+				if (attrValue) attrObj.path = attrValue;
+				break;
+			case "secure":
+				attrObj.secure = true;
+				break;
+			case "httponly":
+				attrObj.httponly = true;
+				break;
+			case "samesite": {
+				const samesite = attrValue.toLowerCase();
+				if ([
+					"lax",
+					"none",
+					"strict"
+				].includes(samesite)) attrObj.samesite = samesite;
+				break;
+			}
+			case "partitioned":
+				attrObj.partitioned = true;
+				break;
+			default:
+				if (normalizedAttrName) attrObj[normalizedAttrName] = attrValue || true;
+				break;
+		}
+	});
+	cookies.set(name, attrObj);
+	return cookies;
+};
+const createCookieCreator = (options) => {
+	const secureCookiePrefix = (options.advanced?.useSecureCookies !== void 0 ? options.advanced.useSecureCookies : options.baseURL !== void 0 ? options.baseURL.startsWith("https://") ? true : false : isProduction()) ? "__Secure-" : "";
+	const crossSubdomainEnabled = options.advanced?.crossSubDomainCookies?.enabled === true;
+	const domain = crossSubdomainEnabled ? options.advanced?.crossSubDomainCookies?.domain ?? (options.baseURL != null ? new URL(options.baseURL).hostname : void 0) : void 0;
+	if (crossSubdomainEnabled && domain == null) throw new FaireAuthError("baseURL is required when crossSubdomainCookies are enabled");
+	const createCookie = (cookieName, overrideAttributes = {}) => {
+		const prefix = options.advanced?.cookiePrefix ?? "faire-auth";
+		const name = options.advanced?.cookies?.[cookieName]?.name ?? `${prefix}.${cookieName}`;
+		const attributes = options.advanced?.cookies?.[cookieName]?.attributes;
+		return {
+			name: `${secureCookiePrefix}${name}`,
+			attributes: {
+				secure: !!secureCookiePrefix,
+				sameSite: "lax",
+				path: "/",
+				httpOnly: true,
+				...crossSubdomainEnabled ? { domain } : {},
+				...options.advanced?.defaultCookieAttributes,
+				...overrideAttributes,
+				...attributes
+			}
+		};
+	};
+	return createCookie;
+};
+const getCookies = (options) => {
+	const createCookie = createCookieCreator(options);
+	const sessionToken = createCookie("session_token", { maxAge: options.session?.expiresIn ?? createTime(7, "d").toSeconds() });
+	const sessionData = createCookie("session_data", { maxAge: options.session?.cookieCache?.maxAge ?? 300 });
+	const dontRememberToken = createCookie("dont_remember");
+	return {
+		sessionToken: {
+			name: sessionToken.name,
+			options: sessionToken.attributes
+		},
+		sessionData: {
+			name: sessionData.name,
+			options: sessionData.attributes
+		},
+		dontRememberToken: {
+			name: dontRememberToken.name,
+			options: dontRememberToken.attributes
+		}
+	};
+};
+const serializeCookies = (cookies) => Array.from(cookies, ([key, value]) => value ? `${key}=${value}` : "").filter(Boolean).join("; ");
+const createCookieSetter = (headers) => (name, value) => {
+	const cookieMap = parseCookies(headers.get("cookie") ?? "");
+	cookieMap.set(name, value);
+	headers.set("cookie", serializeCookies(cookieMap));
+};
+const createCookieCapture = (headers) => (callback) => (context) => {
+	const setCookieHeader = context.response.headers.getSetCookie();
+	if (setCookieHeader.length === 0) return;
+	const cookieMap = new Map([...parseCookies(headers.get("cookie") ?? ""), ...Array.from(parseSetCookieHeader(setCookieHeader), ([key, value]) => [key, value.value])]);
+	headers.set("cookie", serializeCookies(cookieMap));
+	if (callback) callback(cookieMap);
+};
+const getCookieCache = async (request, config) => {
+	const cookies = (request instanceof Headers ? request : request.headers).get("cookie");
+	if (cookies == null) return null;
+	const { cookieName = "session_data", cookiePrefix = "faire-auth" } = config ?? {};
+	const name = config?.isSecure !== void 0 ? config.isSecure ? `__Secure-${cookiePrefix}.${cookieName}` : `${cookiePrefix}.${cookieName}` : isProduction() ? `__Secure-${cookiePrefix}.${cookieName}` : `${cookiePrefix}.${cookieName}`;
+	const sessionData = parseCookies(cookies).get(name);
+	if (sessionData != null) {
+		const sessionDataPayload = safeJSONParse(binary.decode(base64Url.decode(sessionData)));
+		if (!sessionDataPayload) return null;
+		const secret = config?.secret ?? env["FAIRE_AUTH_SECRET"];
+		if (secret == null) throw new FaireAuthError("getCookieCache requires a secret to be provided. Either pass it as an option or set the FAIRE_AUTH_SECRET environment variable");
+		if (!await createHMAC("SHA-256", "base64urlnopad").verify(secret, JSON.stringify({
+			...sessionDataPayload.session,
+			expiresAt: sessionDataPayload.expiresAt
+		}), sessionDataPayload.signature)) return null;
+		return sessionDataPayload.session;
+	}
+	return null;
+};
+const setCookieCache = async (ctx, options, session, dontRememberMe = false) => {
+	const context = ctx.get("context");
+	if (options.session?.cookieCache?.enabled === true) {
+		const sessionData = {
+			session: Object.entries(session.session).reduce((acc, [key, value]) => {
+				const fieldConfig = options.session?.additionalFields?.[key];
+				if (!fieldConfig || fieldConfig.returned !== false) acc[key] = value;
+				return acc;
+			}, {}),
+			user: session.user
+		};
+		const cookieOptions = {
+			...context.authCookies.sessionData.options,
+			...dontRememberMe && { maxAge: context.authCookies.sessionData.options.maxAge }
+		};
+		const expiresAtDate = getDate(cookieOptions.maxAge || 60, "sec").getTime();
+		const data = base64Url.encode(JSON.stringify({
+			session: sessionData,
+			expiresAt: expiresAtDate,
+			signature: await createHMAC("SHA-256", "base64urlnopad").sign(context.secret, JSON.stringify({
+				...sessionData,
+				expiresAt: expiresAtDate
+			}))
+		}), { padding: false });
+		if (data.length > 4093) throw new FaireAuthError("Session data is too large to store in the cookie. Please disable session cookie caching or reduce the size of the session data");
+		hc.setCookie(ctx, context.authCookies.sessionData.name, data, cookieOptions);
+	}
+};
+const getSessionCookie = (request, config) => {
+	if (config?.cookiePrefix != null) if (config.cookieName != null) config.cookiePrefix = `${config.cookiePrefix}-`;
+	else config.cookiePrefix = `${config.cookiePrefix}.`;
+	const cookies = ("headers" in request ? request.headers : request).get("cookie");
+	if (cookies == null) return null;
+	const { cookieName = "session_token", cookiePrefix = "faire-auth." } = config ?? {};
+	const name = `${cookiePrefix}${cookieName}`;
+	const secureCookieName = `__Secure-${name}`;
+	const parsedCookie = parseCookies(cookies);
+	const sessionToken = parsedCookie.get(name) ?? parsedCookie.get(secureCookieName);
+	if (sessionToken != null) return sessionToken;
+	return null;
+};
+const setSessionCookie = (ctx, authOptions, session, dontRememberMe, overrides) => {
+	const context = ctx.get("context");
+	return hc.getSignedCookie(ctx, context.secret, context.authCookies.dontRememberToken.name).then((dontRememberMeCookie) => {
+		dontRememberMe ??= !!dontRememberMeCookie;
+		const options = { ...context.authCookies.sessionToken.options };
+		if (dontRememberMe === true) delete options.maxAge;
+		else options.maxAge = context.sessionConfig.expiresIn;
+		return hc.setSignedCookie(ctx, context.authCookies.sessionToken.name, session.session.token, context.secret, {
+			...options,
+			...overrides
+		});
+	}).then(() => {
+		if (dontRememberMe === true) return hc.setSignedCookie(ctx, context.authCookies.dontRememberToken.name, "true", context.secret, context.authCookies.dontRememberToken.options);
+		return Promise.resolve();
+	}).then(() => {
+		if (authOptions.session?.cookieCache?.enabled === true) return setCookieCache(ctx, authOptions, session, dontRememberMe);
+		return Promise.resolve();
+	}).then(() => {
+		context.newSession = session;
+		if (authOptions.secondaryStorage) {
+			const maybePromise = context.secondaryStorage?.set(session.session.token, JSON.stringify({
+				user: session.user,
+				session: session.session
+			}), Math.floor((new Date(session.session.expiresAt).getTime() - Date.now()) / 1e3));
+			if (isPromise(maybePromise)) return maybePromise;
+		}
+		return Promise.resolve();
+	});
+};
+const deleteSessionCookie = (ctx, skipDontRememberMe) => {
+	const context = ctx.get("context");
+	hc.deleteCookie(ctx, context.authCookies.sessionToken.name, context.authCookies.sessionToken.options);
+	hc.deleteCookie(ctx, context.authCookies.sessionData.name, context.authCookies.sessionData.options);
+	if (!skipDontRememberMe) hc.deleteCookie(ctx, context.authCookies.dontRememberToken.name, context.authCookies.dontRememberToken.options);
+};
+
+//#endregion
+export { serializeSignedCookie as _, createCookieSetter as a, getCookieKey as c, parse as d, parseCookies as f, serializeSigned as g, serialize$1 as h, createCookieCreator as i, getCookies as l, parseSigned as m, cookies_exports as n, deleteSessionCookie as o, parseSetCookieHeader as p, createCookieCapture as r, getCookieCache as s, checkAuthCookie as t, getSessionCookie as u, setCookieCache as v, setSessionCookie as y };

package/dist/crypto/index.cjs

@@ -0,0 +1,11 @@
+const require_crypto = require('../crypto-CcTxYH82.cjs');
+
+exports.checkPassword = require_crypto.checkPassword;
+exports.validatePassword = require_crypto.validatePassword;
+var __faire_auth_core_crypto = require("@faire-auth/core/crypto");
+Object.keys(__faire_auth_core_crypto).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return __faire_auth_core_crypto[k]; }
+  });
+});

package/dist/crypto/index.d.cts

@@ -0,0 +1,22 @@
+import { t as ContextVars } from "../hono-DOM31WQz.cjs";
+import * as _faire_auth_core_types30 from "@faire-auth/core/types";
+import { Context } from "hono";
+export * from "@faire-auth/core/crypto";
+
+//#region src/crypto/index.d.ts
+declare const validatePassword: <T extends object>(ctx: Context<ContextVars<T>>, data: {
+  password: string;
+  userId: string;
+}) => Promise<boolean>;
+declare const checkPassword: <T extends object>(userId: string, ctx: Context<ContextVars<T>, any, {
+  out: {
+    json: {
+      password?: string;
+    };
+  };
+}>) => Promise<true | _faire_auth_core_types30.JSONRespondReturn<{
+  success: false;
+  message: string;
+}, 400>>;
+//#endregion
+export { checkPassword, validatePassword };

package/dist/crypto/index.d.mts

@@ -0,0 +1,22 @@
+import { t as ContextVars } from "../hono-DuE14mmj.mjs";
+import { Context } from "hono";
+import * as _faire_auth_core_types32 from "@faire-auth/core/types";
+export * from "@faire-auth/core/crypto";
+
+//#region src/crypto/index.d.ts
+declare const validatePassword: <T extends object>(ctx: Context<ContextVars<T>>, data: {
+  password: string;
+  userId: string;
+}) => Promise<boolean>;
+declare const checkPassword: <T extends object>(userId: string, ctx: Context<ContextVars<T>, any, {
+  out: {
+    json: {
+      password?: string;
+    };
+  };
+}>) => Promise<true | _faire_auth_core_types32.JSONRespondReturn<{
+  success: false;
+  message: string;
+}, 400>>;
+//#endregion
+export { checkPassword, validatePassword };

package/dist/crypto/index.mjs

@@ -0,0 +1,5 @@
+import { r as validatePassword, t as checkPassword } from "../crypto-CyQRFtkq.mjs";
+
+export * from "@faire-auth/core/crypto"
+
+export { checkPassword, validatePassword };

package/dist/crypto-CcTxYH82.cjs

@@ -0,0 +1,57 @@
+const require_chunk = require('./chunk-oakRccI5.cjs');
+let __faire_auth_core_static = require("@faire-auth/core/static");
+
+//#region src/crypto/index.ts
+var crypto_exports = /* @__PURE__ */ require_chunk.__export({
+	checkPassword: () => checkPassword,
+	validatePassword: () => validatePassword
+});
+require_chunk.__reExport(crypto_exports, require("@faire-auth/core/crypto"));
+const validatePassword = async (ctx, data) => {
+	const context = ctx.get("context");
+	const credentialAccount = (await context.internalAdapter.findAccounts(data.userId)).find((account) => account.providerId === "credential");
+	const currentPassword = credentialAccount?.password;
+	if (!credentialAccount || !currentPassword) return false;
+	return await context.password.verify({
+		hash: currentPassword,
+		password: data.password
+	});
+};
+const checkPassword = async (userId, ctx) => {
+	const context = ctx.get("context");
+	const { password } = ctx.req.valid("json");
+	const credentialAccount = (await context.internalAdapter.findAccounts(userId)).find((account) => account.providerId === "credential");
+	const currentPassword = credentialAccount?.password;
+	if (!credentialAccount || !currentPassword || !password) return ctx.render({
+		success: __faire_auth_core_static.False,
+		message: "No password credential found"
+	}, 400);
+	if (!await context.password.verify({
+		hash: currentPassword,
+		password
+	})) return ctx.render({
+		success: __faire_auth_core_static.False,
+		message: "Invalid password"
+	}, 400);
+	return true;
+};
+
+//#endregion
+Object.defineProperty(exports, 'checkPassword', {
+  enumerable: true,
+  get: function () {
+    return checkPassword;
+  }
+});
+Object.defineProperty(exports, 'crypto_exports', {
+  enumerable: true,
+  get: function () {
+    return crypto_exports;
+  }
+});
+Object.defineProperty(exports, 'validatePassword', {
+  enumerable: true,
+  get: function () {
+    return validatePassword;
+  }
+});

package/dist/crypto-CyQRFtkq.mjs

@@ -0,0 +1,41 @@
+import { n as __export, r as __reExport } from "./chunk-Ceigfy4P.mjs";
+import { False } from "@faire-auth/core/static";
+
+//#region src/crypto/index.ts
+var crypto_exports = /* @__PURE__ */ __export({
+	checkPassword: () => checkPassword,
+	validatePassword: () => validatePassword
+});
+import * as import___faire_auth_core_crypto from "@faire-auth/core/crypto";
+__reExport(crypto_exports, import___faire_auth_core_crypto);
+const validatePassword = async (ctx, data) => {
+	const context = ctx.get("context");
+	const credentialAccount = (await context.internalAdapter.findAccounts(data.userId)).find((account) => account.providerId === "credential");
+	const currentPassword = credentialAccount?.password;
+	if (!credentialAccount || !currentPassword) return false;
+	return await context.password.verify({
+		hash: currentPassword,
+		password: data.password
+	});
+};
+const checkPassword = async (userId, ctx) => {
+	const context = ctx.get("context");
+	const { password } = ctx.req.valid("json");
+	const credentialAccount = (await context.internalAdapter.findAccounts(userId)).find((account) => account.providerId === "credential");
+	const currentPassword = credentialAccount?.password;
+	if (!credentialAccount || !currentPassword || !password) return ctx.render({
+		success: False,
+		message: "No password credential found"
+	}, 400);
+	if (!await context.password.verify({
+		hash: currentPassword,
+		password
+	})) return ctx.render({
+		success: False,
+		message: "Invalid password"
+	}, 400);
+	return true;
+};
+
+//#endregion
+export { crypto_exports as n, validatePassword as r, checkPassword as t };

package/dist/db/index.cjs

@@ -0,0 +1,40 @@
+require('../hono-Cdukwu5K.cjs');
+require('../ip-B5SwXaMB.cjs');
+require('../crypto-CcTxYH82.cjs');
+require('../json-CcJ2HjGo.cjs');
+require('../state--f7fwIGh.cjs');
+require('../request-CPNlp-DK.cjs');
+require('../utils-44aDDP8f.cjs');
+const require_schema = require('../schema-D-qjygfE.cjs');
+require('../kysely-adapter-Bxi7sPdG.cjs');
+const require_adapter_factory = require('../adapter-factory-DT-_2aHJ.cjs');
+const require_db = require('../db-BTKyYu-_.cjs');
+require('../memory-adapter-BlnDIAAX.cjs');
+
+exports.convertFromDB = require_db.convertFromDB;
+exports.convertToDB = require_db.convertToDB;
+exports.createFieldAttribute = require_db.createFieldAttribute;
+exports.createInternalAdapter = require_db.createInternalAdapter;
+exports.getAdapter = require_db.getAdapter;
+exports.getAuthTables = require_adapter_factory.getAuthTables;
+exports.getMigrations = require_db.getMigrations;
+exports.getSchema = require_db.getSchema;
+exports.getWithHooks = require_db.getWithHooks;
+exports.matchType = require_db.matchType;
+exports.mergeSchema = require_schema.mergeSchema;
+exports.parseAccountInput = require_schema.parseAccountInput;
+exports.parseAccountOutput = require_schema.parseAccountOutput;
+exports.parseAdditionalUserInput = require_schema.parseAdditionalUserInput;
+exports.parseInputData = require_schema.parseInputData;
+exports.parseSessionInput = require_schema.parseSessionInput;
+exports.parseSessionOutput = require_schema.parseSessionOutput;
+exports.parseUserInput = require_schema.parseUserInput;
+exports.parseUserOutput = require_schema.parseUserOutput;
+exports.toZodSchema = require_db.toZodSchema;
+var __faire_auth_core_db = require("@faire-auth/core/db");
+Object.keys(__faire_auth_core_db).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return __faire_auth_core_db[k]; }
+  });
+});

package/dist/db/index.d.cts

@@ -0,0 +1,4 @@
+import { $t as PluginFieldAttribute, At as mergeSchema, Bt as getAuthTables, Dt as getAdapter, Et as convertToDB, Ft as parseSessionInput, Gt as FieldAttributeToObject, Ht as getMigrations, It as parseSessionOutput, Jt as InferFieldsFromPlugins, Kt as InferAdditionalFieldsFromPluginOptions, Lt as parseUserInput, Mt as parseAccountOutput, Nt as parseAdditionalUserInput, Ot as FieldAttributeToSchema, Pt as parseInputData, Qt as InferValueType, Rt as parseUserOutput, Tt as convertFromDB, Ut as matchType, Vt as getSchema, Xt as InferFieldsInputClient, Yt as InferFieldsInput, Zt as InferFieldsOutput, en as createFieldAttribute, jt as parseAccountInput, kt as toZodSchema, qt as InferFieldsFromOptions, wt as getWithHooks, zt as createInternalAdapter } from "../index-B-WeOMzg.cjs";
+import "../hono-DOM31WQz.cjs";
+export * from "@faire-auth/core/db";
+export { FieldAttributeToObject, FieldAttributeToSchema, InferAdditionalFieldsFromPluginOptions, InferFieldsFromOptions, InferFieldsFromPlugins, InferFieldsInput, InferFieldsInputClient, InferFieldsOutput, InferValueType, PluginFieldAttribute, convertFromDB, convertToDB, createFieldAttribute, createInternalAdapter, getAdapter, getAuthTables, getMigrations, getSchema, getWithHooks, matchType, mergeSchema, parseAccountInput, parseAccountOutput, parseAdditionalUserInput, parseInputData, parseSessionInput, parseSessionOutput, parseUserInput, parseUserOutput, toZodSchema };

package/dist/db/index.d.mts

@@ -0,0 +1,4 @@
+import { $t as PluginFieldAttribute, At as mergeSchema, Bt as getAuthTables, Dt as getAdapter, Et as convertToDB, Ft as parseSessionInput, Gt as FieldAttributeToObject, Ht as getMigrations, It as parseSessionOutput, Jt as InferFieldsFromPlugins, Kt as InferAdditionalFieldsFromPluginOptions, Lt as parseUserInput, Mt as parseAccountOutput, Nt as parseAdditionalUserInput, Ot as FieldAttributeToSchema, Pt as parseInputData, Qt as InferValueType, Rt as parseUserOutput, Tt as convertFromDB, Ut as matchType, Vt as getSchema, Xt as InferFieldsInputClient, Yt as InferFieldsInput, Zt as InferFieldsOutput, en as createFieldAttribute, jt as parseAccountInput, kt as toZodSchema, qt as InferFieldsFromOptions, wt as getWithHooks, zt as createInternalAdapter } from "../index-jlessPI0.mjs";
+import "../hono-DuE14mmj.mjs";
+export * from "@faire-auth/core/db";
+export { FieldAttributeToObject, FieldAttributeToSchema, InferAdditionalFieldsFromPluginOptions, InferFieldsFromOptions, InferFieldsFromPlugins, InferFieldsInput, InferFieldsInputClient, InferFieldsOutput, InferValueType, PluginFieldAttribute, convertFromDB, convertToDB, createFieldAttribute, createInternalAdapter, getAdapter, getAuthTables, getMigrations, getSchema, getWithHooks, matchType, mergeSchema, parseAccountInput, parseAccountOutput, parseAdditionalUserInput, parseInputData, parseSessionInput, parseSessionOutput, parseUserInput, parseUserOutput, toZodSchema };

package/dist/db/index.mjs

@@ -0,0 +1,16 @@
+import "../hono-CoKYWnXA.mjs";
+import "../ip-BjNYspCH.mjs";
+import "../crypto-CyQRFtkq.mjs";
+import "../json-B1v2qRTQ.mjs";
+import "../state-CqJfCIl9.mjs";
+import "../request-1NL_1lyJ.mjs";
+import "../utils-D4vZd1-9.mjs";
+import { a as parseInputData, c as parseUserInput, i as parseAdditionalUserInput, l as parseUserOutput, n as parseAccountInput, o as parseSessionInput, r as parseAccountOutput, s as parseSessionOutput, t as mergeSchema } from "../schema-DTIwLLmf.mjs";
+import "../kysely-adapter-DRuoT_X8.mjs";
+import { n as getAuthTables } from "../adapter-factory-BXei1QRX.mjs";
+import { a as createInternalAdapter, c as matchType, i as toZodSchema, l as getSchema, n as convertToDB, o as getWithHooks, r as getAdapter, s as getMigrations, t as convertFromDB, u as createFieldAttribute } from "../db-xiJtoDgz.mjs";
+import "../memory-adapter-Db3tsJTn.mjs";
+
+export * from "@faire-auth/core/db"
+
+export { convertFromDB, convertToDB, createFieldAttribute, createInternalAdapter, getAdapter, getAuthTables, getMigrations, getSchema, getWithHooks, matchType, mergeSchema, parseAccountInput, parseAccountOutput, parseAdditionalUserInput, parseInputData, parseSessionInput, parseSessionOutput, parseUserInput, parseUserOutput, toZodSchema };