faire-auth 1.0.0

package/dist/node-sqlite-dialect-BfBzyOAg.mjs

@@ -0,0 +1,155 @@
+import { CompiledQuery, DEFAULT_MIGRATION_LOCK_TABLE, DEFAULT_MIGRATION_TABLE, DefaultQueryCompiler, Kysely, sql } from "kysely";
+
+//#region src/adapters/kysely-adapter/node-sqlite-dialect.ts
+var NodeSqliteAdapter = class {
+	get supportsCreateIfNotExists() {
+		return true;
+	}
+	get supportsTransactionalDdl() {
+		return false;
+	}
+	get supportsReturning() {
+		return true;
+	}
+	async acquireMigrationLock() {}
+	async releaseMigrationLock() {}
+	get supportsOutput() {
+		return true;
+	}
+};
+var NodeSqliteDriver = class {
+	#config;
+	#connectionMutex = new ConnectionMutex();
+	#db;
+	#connection;
+	constructor(config) {
+		this.#config = { ...config };
+	}
+	async init() {
+		this.#db = this.#config.database;
+		this.#connection = new NodeSqliteConnection(this.#db);
+		if (this.#config.onCreateConnection) await this.#config.onCreateConnection(this.#connection);
+	}
+	async acquireConnection() {
+		await this.#connectionMutex.lock();
+		return this.#connection;
+	}
+	async beginTransaction(connection) {
+		await connection.executeQuery(CompiledQuery.raw("begin"));
+	}
+	async commitTransaction(connection) {
+		await connection.executeQuery(CompiledQuery.raw("commit"));
+	}
+	async rollbackTransaction(connection) {
+		await connection.executeQuery(CompiledQuery.raw("rollback"));
+	}
+	async releaseConnection() {
+		this.#connectionMutex.unlock();
+	}
+	async destroy() {
+		this.#db?.close();
+	}
+};
+var NodeSqliteConnection = class {
+	#db;
+	constructor(db) {
+		this.#db = db;
+	}
+	executeQuery(compiledQuery) {
+		const { sql: sql$1, parameters } = compiledQuery;
+		const rows = this.#db.prepare(sql$1).all(...parameters);
+		return Promise.resolve({ rows });
+	}
+	async *streamQuery() {
+		throw new Error("Streaming query is not supported by SQLite driver.");
+	}
+};
+var ConnectionMutex = class {
+	#promise;
+	#resolve;
+	async lock() {
+		while (this.#promise) await this.#promise;
+		this.#promise = new Promise((resolve) => {
+			this.#resolve = resolve;
+		});
+	}
+	unlock() {
+		const resolve = this.#resolve;
+		this.#promise = void 0;
+		this.#resolve = void 0;
+		resolve?.();
+	}
+};
+var NodeSqliteIntrospector = class {
+	#db;
+	constructor(db) {
+		this.#db = db;
+	}
+	async getSchemas() {
+		return [];
+	}
+	async getTables(options = { withInternalKyselyTables: false }) {
+		let query = this.#db.selectFrom("sqlite_schema").where("type", "=", "table").where("name", "not like", "sqlite_%").select("name").$castTo();
+		if (!options.withInternalKyselyTables) query = query.where("name", "!=", DEFAULT_MIGRATION_TABLE).where("name", "!=", DEFAULT_MIGRATION_LOCK_TABLE);
+		const tables = await query.execute();
+		return Promise.all(tables.map(({ name }) => this.#getTableMetadata(name)));
+	}
+	async getMetadata(options) {
+		return { tables: await this.getTables(options) };
+	}
+	async #getTableMetadata(table) {
+		const db = this.#db;
+		const autoIncrementCol = (await db.selectFrom("sqlite_master").where("name", "=", table).select("sql").$castTo().execute())[0]?.sql?.split(/[\(\),]/)?.find((it) => it.toLowerCase().includes("autoincrement"))?.split(/\s+/)?.[0]?.replace(/["`]/g, "");
+		return {
+			name: table,
+			columns: (await db.selectFrom(sql`pragma_table_info(${table})`.as("table_info")).select([
+				"name",
+				"type",
+				"notnull",
+				"dflt_value"
+			]).execute()).map((col) => ({
+				name: col.name,
+				dataType: col.type,
+				isNullable: !col.notnull,
+				isAutoIncrementing: col.name === autoIncrementCol,
+				hasDefaultValue: col.dflt_value != null
+			})),
+			isView: true
+		};
+	}
+};
+var NodeSqliteQueryCompiler = class extends DefaultQueryCompiler {
+	getCurrentParameterPlaceholder() {
+		return "?";
+	}
+	getLeftIdentifierWrapper() {
+		return "\"";
+	}
+	getRightIdentifierWrapper() {
+		return "\"";
+	}
+	getAutoIncrement() {
+		return "autoincrement";
+	}
+};
+var NodeSqliteDialect = class {
+	#config;
+	constructor(config) {
+		this.#config = { ...config };
+	}
+	createDriver() {
+		return new NodeSqliteDriver(this.#config);
+	}
+	createQueryCompiler() {
+		return new NodeSqliteQueryCompiler();
+	}
+	createAdapter() {
+		return new NodeSqliteAdapter();
+	}
+	createIntrospector(db) {
+		return new NodeSqliteIntrospector(db);
+	}
+};
+
+//#endregion
+export { NodeSqliteAdapter, NodeSqliteDialect, NodeSqliteDriver, NodeSqliteIntrospector, NodeSqliteQueryCompiler };

package/dist/node-sqlite-dialect-mJWC8LWQ.cjs

@@ -0,0 +1,156 @@
+const require_chunk = require('./chunk-oakRccI5.cjs');
+let kysely = require("kysely");
+
+//#region src/adapters/kysely-adapter/node-sqlite-dialect.ts
+var NodeSqliteAdapter = class {
+	get supportsCreateIfNotExists() {
+		return true;
+	}
+	get supportsTransactionalDdl() {
+		return false;
+	}
+	get supportsReturning() {
+		return true;
+	}
+	async acquireMigrationLock() {}
+	async releaseMigrationLock() {}
+	get supportsOutput() {
+		return true;
+	}
+};
+var NodeSqliteDriver = class {
+	#config;
+	#connectionMutex = new ConnectionMutex();
+	#db;
+	#connection;
+	constructor(config) {
+		this.#config = { ...config };
+	}
+	async init() {
+		this.#db = this.#config.database;
+		this.#connection = new NodeSqliteConnection(this.#db);
+		if (this.#config.onCreateConnection) await this.#config.onCreateConnection(this.#connection);
+	}
+	async acquireConnection() {
+		await this.#connectionMutex.lock();
+		return this.#connection;
+	}
+	async beginTransaction(connection) {
+		await connection.executeQuery(kysely.CompiledQuery.raw("begin"));
+	}
+	async commitTransaction(connection) {
+		await connection.executeQuery(kysely.CompiledQuery.raw("commit"));
+	}
+	async rollbackTransaction(connection) {
+		await connection.executeQuery(kysely.CompiledQuery.raw("rollback"));
+	}
+	async releaseConnection() {
+		this.#connectionMutex.unlock();
+	}
+	async destroy() {
+		this.#db?.close();
+	}
+};
+var NodeSqliteConnection = class {
+	#db;
+	constructor(db) {
+		this.#db = db;
+	}
+	executeQuery(compiledQuery) {
+		const { sql: sql$1, parameters } = compiledQuery;
+		const rows = this.#db.prepare(sql$1).all(...parameters);
+		return Promise.resolve({ rows });
+	}
+	async *streamQuery() {
+		throw new Error("Streaming query is not supported by SQLite driver.");
+	}
+};
+var ConnectionMutex = class {
+	#promise;
+	#resolve;
+	async lock() {
+		while (this.#promise) await this.#promise;
+		this.#promise = new Promise((resolve) => {
+			this.#resolve = resolve;
+		});
+	}
+	unlock() {
+		const resolve = this.#resolve;
+		this.#promise = void 0;
+		this.#resolve = void 0;
+		resolve?.();
+	}
+};
+var NodeSqliteIntrospector = class {
+	#db;
+	constructor(db) {
+		this.#db = db;
+	}
+	async getSchemas() {
+		return [];
+	}
+	async getTables(options = { withInternalKyselyTables: false }) {
+		let query = this.#db.selectFrom("sqlite_schema").where("type", "=", "table").where("name", "not like", "sqlite_%").select("name").$castTo();
+		if (!options.withInternalKyselyTables) query = query.where("name", "!=", kysely.DEFAULT_MIGRATION_TABLE).where("name", "!=", kysely.DEFAULT_MIGRATION_LOCK_TABLE);
+		const tables = await query.execute();
+		return Promise.all(tables.map(({ name }) => this.#getTableMetadata(name)));
+	}
+	async getMetadata(options) {
+		return { tables: await this.getTables(options) };
+	}
+	async #getTableMetadata(table) {
+		const db = this.#db;
+		const autoIncrementCol = (await db.selectFrom("sqlite_master").where("name", "=", table).select("sql").$castTo().execute())[0]?.sql?.split(/[\(\),]/)?.find((it) => it.toLowerCase().includes("autoincrement"))?.split(/\s+/)?.[0]?.replace(/["`]/g, "");
+		return {
+			name: table,
+			columns: (await db.selectFrom(kysely.sql`pragma_table_info(${table})`.as("table_info")).select([
+				"name",
+				"type",
+				"notnull",
+				"dflt_value"
+			]).execute()).map((col) => ({
+				name: col.name,
+				dataType: col.type,
+				isNullable: !col.notnull,
+				isAutoIncrementing: col.name === autoIncrementCol,
+				hasDefaultValue: col.dflt_value != null
+			})),
+			isView: true
+		};
+	}
+};
+var NodeSqliteQueryCompiler = class extends kysely.DefaultQueryCompiler {
+	getCurrentParameterPlaceholder() {
+		return "?";
+	}
+	getLeftIdentifierWrapper() {
+		return "\"";
+	}
+	getRightIdentifierWrapper() {
+		return "\"";
+	}
+	getAutoIncrement() {
+		return "autoincrement";
+	}
+};
+var NodeSqliteDialect = class {
+	#config;
+	constructor(config) {
+		this.#config = { ...config };
+	}
+	createDriver() {
+		return new NodeSqliteDriver(this.#config);
+	}
+	createQueryCompiler() {
+		return new NodeSqliteQueryCompiler();
+	}
+	createAdapter() {
+		return new NodeSqliteAdapter();
+	}
+	createIntrospector(db) {
+		return new NodeSqliteIntrospector(db);
+	}
+};
+
+//#endregion
+exports.NodeSqliteDialect = NodeSqliteDialect;

package/dist/oauth2/index.cjs

@@ -0,0 +1,25 @@
+require('../hono-Cdukwu5K.cjs');
+require('../crypto-CcTxYH82.cjs');
+require('../json-CcJ2HjGo.cjs');
+require('../cookies-B5xeA6i8.cjs');
+require('../logged-DQK3C64b.cjs');
+require('../url-D2yvKaM7.cjs');
+require('../middleware-CWvRH4EW.cjs');
+require('../session-De9POJTW.cjs');
+require('../origin-check-id9lTnqZ.cjs');
+require('../email-verification-C-AsfJsb.cjs');
+const require_oauth2 = require('../oauth2-BLeOEi7Y.cjs');
+const require_state = require('../state--f7fwIGh.cjs');
+
+exports.decryptOAuthToken = require_oauth2.decryptOAuthToken;
+exports.generateState = require_state.generateState;
+exports.handleOAuthUserInfo = require_oauth2.handleOAuthUserInfo;
+exports.parseState = require_state.parseState;
+exports.setTokenUtil = require_oauth2.setTokenUtil;
+var __faire_auth_core_oauth2 = require("@faire-auth/core/oauth2");
+Object.keys(__faire_auth_core_oauth2).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return __faire_auth_core_oauth2[k]; }
+  });
+});

package/dist/oauth2/index.d.cts

@@ -0,0 +1,42 @@
+import { I as FaireAuthOptions$1, M as generateState, N as parseState } from "../index-B-WeOMzg.cjs";
+import { t as ContextVars } from "../hono-DOM31WQz.cjs";
+import { ExK } from "@faire-auth/core/types";
+import { Context, TypedResponse } from "hono";
+import { Account, Session, User } from "@faire-auth/core/db";
+export * from "@faire-auth/core/oauth2";
+
+//#region src/oauth2/utils.d.ts
+declare const decryptOAuthToken: <V extends object>(token: string, ctx: Context<ContextVars<V>>, options: Pick<FaireAuthOptions$1, "account">) => string | Promise<string>;
+declare const setTokenUtil: <V extends object>(token: string | null | undefined, ctx: Context<ContextVars<V>>, options: Pick<FaireAuthOptions$1, "account">) => string | Promise<string> | null | undefined;
+//#endregion
+//#region src/oauth2/link-account.d.ts
+type OAuthError = "account_not_linked" | "unable_to_link_account" | "unable_to_create_user" | "unable_to_create_session" | "internal_server_error" | "signup_disabled" | (string & {});
+declare const handleOAuthUserInfo: (ctx: Context<ContextVars>, {
+  userInfo,
+  account,
+  callbackURL,
+  disableSignUp,
+  overrideUserInfo
+}: {
+  userInfo: ExK<User, "createdAt" | "updatedAt">;
+  account: ExK<Account, "createdAt" | "id" | "updatedAt" | "userId">;
+  callbackURL?: string;
+  disableSignUp?: boolean;
+  overrideUserInfo?: boolean;
+}, options: Pick<FaireAuthOptions$1, "account" | "emailVerification" | "onAPIError">) => Promise<{
+  type: "success";
+  data: {
+    session: Session;
+    user: User;
+  };
+  isRegister: boolean;
+} | {
+  type: "redirect";
+  response: Response & TypedResponse<undefined, 302, "redirect">;
+} | {
+  type: "error";
+  reason: OAuthError;
+  isRegister?: false;
+}>;
+//#endregion
+export { decryptOAuthToken, generateState, handleOAuthUserInfo, parseState, setTokenUtil };

package/dist/oauth2/index.d.mts

@@ -0,0 +1,42 @@
+import { I as FaireAuthOptions$1, M as generateState, N as parseState } from "../index-jlessPI0.mjs";
+import { t as ContextVars } from "../hono-DuE14mmj.mjs";
+import { Context, TypedResponse } from "hono";
+import { Account, Session, User } from "@faire-auth/core/db";
+import { ExK } from "@faire-auth/core/types";
+export * from "@faire-auth/core/oauth2";
+
+//#region src/oauth2/utils.d.ts
+declare const decryptOAuthToken: <V extends object>(token: string, ctx: Context<ContextVars<V>>, options: Pick<FaireAuthOptions$1, "account">) => string | Promise<string>;
+declare const setTokenUtil: <V extends object>(token: string | null | undefined, ctx: Context<ContextVars<V>>, options: Pick<FaireAuthOptions$1, "account">) => string | Promise<string> | null | undefined;
+//#endregion
+//#region src/oauth2/link-account.d.ts
+type OAuthError = "account_not_linked" | "unable_to_link_account" | "unable_to_create_user" | "unable_to_create_session" | "internal_server_error" | "signup_disabled" | (string & {});
+declare const handleOAuthUserInfo: (ctx: Context<ContextVars>, {
+  userInfo,
+  account,
+  callbackURL,
+  disableSignUp,
+  overrideUserInfo
+}: {
+  userInfo: ExK<User, "createdAt" | "updatedAt">;
+  account: ExK<Account, "createdAt" | "id" | "updatedAt" | "userId">;
+  callbackURL?: string;
+  disableSignUp?: boolean;
+  overrideUserInfo?: boolean;
+}, options: Pick<FaireAuthOptions$1, "account" | "emailVerification" | "onAPIError">) => Promise<{
+  type: "success";
+  data: {
+    session: Session;
+    user: User;
+  };
+  isRegister: boolean;
+} | {
+  type: "redirect";
+  response: Response & TypedResponse<undefined, 302, "redirect">;
+} | {
+  type: "error";
+  reason: OAuthError;
+  isRegister?: false;
+}>;
+//#endregion
+export { decryptOAuthToken, generateState, handleOAuthUserInfo, parseState, setTokenUtil };

package/dist/oauth2/index.mjs

@@ -0,0 +1,16 @@
+import "../hono-CoKYWnXA.mjs";
+import "../crypto-CyQRFtkq.mjs";
+import "../json-B1v2qRTQ.mjs";
+import "../cookies-Ch1JfQIz.mjs";
+import "../logged-CyGfp8_H.mjs";
+import "../url-BoUuoIwZ.mjs";
+import "../middleware-CE6OhDkq.mjs";
+import "../session-rH8ougDl.mjs";
+import "../origin-check-8Gajklvh.mjs";
+import "../email-verification-CWhj2qfb.mjs";
+import { n as decryptOAuthToken, r as setTokenUtil, t as handleOAuthUserInfo } from "../oauth2-B8M0lW9l.mjs";
+import { n as parseState, t as generateState } from "../state-CqJfCIl9.mjs";
+
+export * from "@faire-auth/core/oauth2"
+
+export { decryptOAuthToken, generateState, handleOAuthUserInfo, parseState, setTokenUtil };

package/dist/oauth2-B8M0lW9l.mjs

@@ -0,0 +1,159 @@
+import { n as crypto_exports } from "./crypto-CyQRFtkq.mjs";
+import { t as createEmailVerificationToken } from "./email-verification-CWhj2qfb.mjs";
+import { isDevelopment, logger } from "@faire-auth/core/env";
+import { APIError } from "@faire-auth/core/error";
+
+//#region src/oauth2/utils.ts
+const decryptOAuthToken = (token, ctx, options) => {
+	if (!token) return token;
+	if (options.account?.encryptOAuthTokens) return (0, crypto_exports.symmetricDecrypt)({
+		key: ctx.get("context").secret,
+		data: token
+	});
+	return token;
+};
+const setTokenUtil = (token, ctx, options) => {
+	if (options.account?.encryptOAuthTokens && token) return (0, crypto_exports.symmetricEncrypt)({
+		key: ctx.get("context").secret,
+		data: token
+	});
+	return token;
+};
+
+//#endregion
+//#region src/oauth2/link-account.ts
+const handleOAuthUserInfo = async (ctx, { userInfo, account, callbackURL, disableSignUp, overrideUserInfo }, options) => {
+	const context = ctx.get("context");
+	const redirectOnError = (reason) => {
+		const errorURL = options.onAPIError?.errorURL ?? `${context.baseURL}/error`;
+		return {
+			type: "redirect",
+			response: ctx.redirect(`${errorURL}?error=${reason}`, 302)
+		};
+	};
+	const dbUser = await context.internalAdapter.findOAuthUser(userInfo.email.toLowerCase(), account.accountId, account.providerId).catch((e) => {
+		logger.error("Better auth was unable to query your database.\nError: ", e);
+		return "error";
+	});
+	if (dbUser === "error") return redirectOnError("internal_server_error");
+	let user = dbUser?.user ?? null;
+	const isRegister = user == null;
+	if (dbUser) {
+		const hasBeenLinked = dbUser.accounts.find((a) => a.providerId === account.providerId && a.accountId === account.accountId);
+		if (!hasBeenLinked) {
+			if (!(options.account?.accountLinking?.trustedProviders)?.includes(account.providerId) && !userInfo.emailVerified || options.account?.accountLinking?.enabled === false) {
+				if (isDevelopment()) logger.warn(`User already exist but account isn't linked to ${account.providerId}. To read more about how account linking works in Faire Auth see https://www.faire-auth.com/docs/concepts/users-accounts#account-linking.`);
+				return {
+					type: "error",
+					reason: "account_not_linked"
+				};
+			}
+			try {
+				await context.internalAdapter.linkAccount({
+					providerId: account.providerId,
+					accountId: userInfo.id.toString(),
+					userId: dbUser.user.id,
+					accessToken: await setTokenUtil(account.accessToken, ctx, options),
+					refreshToken: await setTokenUtil(account.refreshToken, ctx, options),
+					idToken: account.idToken,
+					accessTokenExpiresAt: account.accessTokenExpiresAt,
+					refreshTokenExpiresAt: account.refreshTokenExpiresAt,
+					scope: account.scope
+				});
+			} catch (e) {
+				logger.error("Unable to link account", e);
+				return {
+					type: "error",
+					reason: "unable_to_link_account"
+				};
+			}
+			if (userInfo.emailVerified && !dbUser.user.emailVerified && userInfo.email.toLowerCase() === dbUser.user.email) await context.internalAdapter.updateUser(dbUser.user.id, { emailVerified: true });
+		} else {
+			if (options.account?.updateAccountOnSignIn !== false) {
+				const updateData = Object.fromEntries(Object.entries({
+					idToken: account.idToken,
+					accessToken: await setTokenUtil(account.accessToken, ctx, options),
+					refreshToken: await setTokenUtil(account.refreshToken, ctx, options),
+					accessTokenExpiresAt: account.accessTokenExpiresAt,
+					refreshTokenExpiresAt: account.refreshTokenExpiresAt,
+					scope: account.scope
+				}).filter(([, value]) => value !== void 0 && value !== ""));
+				if (Object.keys(updateData).length > 0) await context.internalAdapter.updateAccount(hasBeenLinked.id, updateData);
+			}
+			if (userInfo.emailVerified && !dbUser.user.emailVerified && userInfo.email.toLowerCase() === dbUser.user.email) await context.internalAdapter.updateUser(dbUser.user.id, { emailVerified: true });
+		}
+		if (overrideUserInfo === true) {
+			const { id: _,...restUserInfo } = userInfo;
+			await context.internalAdapter.updateUser(dbUser.user.id, {
+				...restUserInfo,
+				email: userInfo.email.toLowerCase(),
+				emailVerified: userInfo.email.toLowerCase() === dbUser.user.email ? dbUser.user.emailVerified || userInfo.emailVerified : userInfo.emailVerified
+			});
+		}
+	} else {
+		if (disableSignUp === true) return {
+			type: "error",
+			reason: "signup_disabled",
+			isRegister: false
+		};
+		try {
+			const { id: _,...restUserInfo } = userInfo;
+			user = await context.internalAdapter.createOAuthUser({
+				...restUserInfo,
+				email: userInfo.email.toLowerCase()
+			}, {
+				accessToken: await setTokenUtil(account.accessToken, ctx, options),
+				refreshToken: await setTokenUtil(account.refreshToken, ctx, options),
+				idToken: account.idToken,
+				accessTokenExpiresAt: account.accessTokenExpiresAt,
+				refreshTokenExpiresAt: account.refreshTokenExpiresAt,
+				scope: account.scope,
+				providerId: account.providerId,
+				accountId: userInfo.id.toString()
+			}).then((res) => res.user);
+			if (!userInfo.emailVerified && user && options.emailVerification?.sendOnSignUp === true) {
+				const token = await createEmailVerificationToken(context.secret, user.email, void 0, options.emailVerification.expiresIn);
+				const url = `${context.baseURL}/verify-email?token=${token}${callbackURL ? `&callbackURL=${callbackURL}` : ""}`;
+				await options.emailVerification.sendVerificationEmail?.({
+					user,
+					url,
+					token
+				}, ctx);
+			}
+		} catch (e) {
+			logger.error(e instanceof Error ? e.message : String(e), e);
+			if (e instanceof APIError) return {
+				type: "error",
+				reason: e.message,
+				isRegister: false
+			};
+			return {
+				type: "error",
+				reason: "unable_to_create_user",
+				isRegister: false
+			};
+		}
+	}
+	if (!user) return {
+		type: "error",
+		reason: "unable_to_create_user",
+		isRegister: false
+	};
+	const session = await context.internalAdapter.createSession(user.id);
+	if (!session) return {
+		type: "error",
+		reason: "unable_to_create_session",
+		isRegister: false
+	};
+	return {
+		type: "success",
+		data: {
+			session,
+			user
+		},
+		isRegister
+	};
+};
+
+//#endregion
+export { decryptOAuthToken as n, setTokenUtil as r, handleOAuthUserInfo as t };