faire-auth 1.0.0

package/dist/kysely-adapter-Bxi7sPdG.cjs

@@ -0,0 +1,288 @@
+const require_chunk = require('./chunk-oakRccI5.cjs');
+const require_adapter_factory = require('./adapter-factory-DT-_2aHJ.cjs');
+let __faire_auth_core_static = require("@faire-auth/core/static");
+let kysely = require("kysely");
+
+//#region src/adapters/kysely-adapter/dialect.ts
+function getKyselyDatabaseType(db) {
+	if (!db) return null;
+	if ("dialect" in db) return getKyselyDatabaseType(db.dialect);
+	if ("createDriver" in db) {
+		if (db instanceof kysely.SqliteDialect) return "sqlite";
+		if (db instanceof kysely.MysqlDialect) return "mysql";
+		if (db instanceof kysely.PostgresDialect) return "postgres";
+		if (db instanceof kysely.MssqlDialect) return "mssql";
+	}
+	if ("aggregate" in db) return "sqlite";
+	if ("getConnection" in db) return "mysql";
+	if ("connect" in db) return "postgres";
+	if ("fileControl" in db) return "sqlite";
+	if ("open" in db && "close" in db && "prepare" in db) return "sqlite";
+	return null;
+}
+const createKyselyAdapter = (config) => {
+	const db = config.database;
+	if (!db) return {
+		kysely: null,
+		databaseType: null,
+		transaction: void 0
+	};
+	if ("db" in db) return {
+		kysely: db.db,
+		databaseType: db.type,
+		transaction: db.transaction
+	};
+	if ("dialect" in db) return {
+		kysely: new kysely.Kysely({ dialect: db.dialect }),
+		databaseType: db.type,
+		transaction: db.transaction
+	};
+	let dialect = void 0;
+	const databaseType = getKyselyDatabaseType(db);
+	if ("createDriver" in db) dialect = db;
+	if ("aggregate" in db && !("createSession" in db)) dialect = new kysely.SqliteDialect({ database: db });
+	if ("getConnection" in db) dialect = new kysely.MysqlDialect(db);
+	if ("connect" in db) dialect = new kysely.PostgresDialect({ pool: db });
+	const toReturn = {
+		kysely: dialect ? new kysely.Kysely({ dialect }) : null,
+		databaseType,
+		transaction: void 0,
+		async initialize() {
+			if (toReturn.kysely == null) {
+				if ("fileControl" in db) {
+					console.log("found file control");
+					const { BunSqliteDialect } = await Promise.resolve().then(() => require("./bun-sqlite-dialect-wuaC2-gh.cjs"));
+					dialect = new BunSqliteDialect({ database: db });
+				}
+				if ("createSession" in db && typeof window === "undefined") {
+					console.log("found create session");
+					let DatabaseSync = void 0;
+					try {
+						let nodeSqlite = "node:sqlite";
+						({DatabaseSync} = await import(
+							/* @vite-ignore */
+							/* webpackIgnore: true */
+							nodeSqlite
+));
+					} catch (error) {
+						console.log("caught");
+						if (error !== null && typeof error === "object" && "code" in error && error.code !== "ERR_UNKNOWN_BUILTIN_MODULE") throw error;
+					}
+					console.log("import dialect");
+					if (DatabaseSync && db instanceof DatabaseSync) {
+						const { NodeSqliteDialect } = await Promise.resolve().then(() => require("./node-sqlite-dialect-mJWC8LWQ.cjs"));
+						dialect = new NodeSqliteDialect({ database: db });
+					}
+				}
+				if (dialect) toReturn.kysely = new kysely.Kysely({ dialect });
+			}
+		}
+	};
+	return toReturn;
+};
+
+//#endregion
+//#region src/adapters/kysely-adapter/kysely-adapter.ts
+const withDbInit = (db, work) => async (fn) => {
+	const rdb = (0, __faire_auth_core_static.isPromise)(db) ? await db : db;
+	if (work) work(rdb);
+	return fn(rdb);
+};
+const kyselyAdapter = (db, config) => {
+	let lazyOptions = null;
+	const withDb = withDbInit(db);
+	const createCustomAdapter = (db$1) => {
+		return ({ getFieldName }) => {
+			const withReturningInit = (db$2) => async (values, builder, model, where) => {
+				let res;
+				if (config?.type === "mysql") {
+					await builder.execute();
+					const field = values.id ? "id" : where.length > 0 && where[0]?.field ? where[0].field : "id";
+					if (!values.id && where.length === 0) {
+						res = await db$2.selectFrom(model).selectAll().orderBy(getFieldName({
+							model,
+							field
+						}), "desc").limit(1).executeTakeFirst();
+						return res;
+					}
+					const value = values[field] || where[0]?.value;
+					res = await db$2.selectFrom(model).selectAll().orderBy(getFieldName({
+						model,
+						field
+					}), "desc").where(getFieldName({
+						model,
+						field
+					}), "=", value).limit(1).executeTakeFirst();
+					return res;
+				}
+				if (config?.type === "mssql") {
+					res = await builder.outputAll("inserted").executeTakeFirst();
+					return res;
+				}
+				res = await builder.returningAll().executeTakeFirst();
+				return res;
+			};
+			let withReturning;
+			const withDb$1 = withDbInit(db$1, (db$2) => withReturning ??= withReturningInit(db$2));
+			function convertWhereClause(model, w) {
+				if (!w) return {
+					and: null,
+					or: null
+				};
+				const conditions = {
+					and: [],
+					or: []
+				};
+				w.forEach((condition) => {
+					let { field: _field, value: _value, operator = "=", connector = "AND" } = condition;
+					let value = _value;
+					let field = getFieldName({
+						model,
+						field: _field
+					});
+					const expr = (eb) => {
+						if (operator.toLowerCase() === "in") return eb(field, "in", Array.isArray(value) ? value : [value]);
+						if (operator.toLowerCase() === "not_in") return eb(field, "not in", Array.isArray(value) ? value : [value]);
+						if (operator === "contains") return eb(field, "like", `%${value}%`);
+						if (operator === "starts_with") return eb(field, "like", `${value}%`);
+						if (operator === "ends_with") return eb(field, "like", `%${value}`);
+						if (operator === "eq") return eb(field, "=", value);
+						if (operator === "ne") return eb(field, "<>", value);
+						if (operator === "gt") return eb(field, ">", value);
+						if (operator === "gte") return eb(field, ">=", value);
+						if (operator === "lt") return eb(field, "<", value);
+						if (operator === "lte") return eb(field, "<=", value);
+						return eb(field, operator, value);
+					};
+					if (connector === "OR") conditions.or.push(expr);
+					else conditions.and.push(expr);
+				});
+				return {
+					and: conditions.and.length ? conditions.and : null,
+					or: conditions.or.length ? conditions.or : null
+				};
+			}
+			return {
+				create: ({ data, model }) => withDb$1(async (db$2) => {
+					const builder = db$2.insertInto(model).values(data);
+					return await withReturning(data, builder, model, []);
+				}),
+				findOne: ({ model, where, select }) => withDb$1(async (db$2) => {
+					const { and, or } = convertWhereClause(model, where);
+					let query = db$2.selectFrom(model).selectAll();
+					if (and) query = query.where((eb) => eb.and(and.map((expr) => expr(eb))));
+					if (or) query = query.where((eb) => eb.or(or.map((expr) => expr(eb))));
+					const res = await query.executeTakeFirst();
+					if (!res) return null;
+					return res;
+				}),
+				findMany: ({ model, where, limit, offset, sortBy }) => withDb$1(async (db$2) => {
+					const { and, or } = convertWhereClause(model, where);
+					let query = db$2.selectFrom(model);
+					if (and) query = query.where((eb) => eb.and(and.map((expr) => expr(eb))));
+					if (or) query = query.where((eb) => eb.or(or.map((expr) => expr(eb))));
+					if (config?.type === "mssql") {
+						if (!offset) query = query.top(limit || 100);
+					} else query = query.limit(limit || 100);
+					if (sortBy) query = query.orderBy(getFieldName({
+						model,
+						field: sortBy.field
+					}), sortBy.direction);
+					if (offset) if (config?.type === "mssql") {
+						if (!sortBy) query = query.orderBy(getFieldName({
+							model,
+							field: "id"
+						}));
+						query = query.offset(offset).fetch(limit || 100);
+					} else query = query.offset(offset);
+					const res = await query.selectAll().execute();
+					if (!res) return [];
+					return res;
+				}),
+				update: ({ model, where, update: values }) => withDb$1(async (db$2) => {
+					const { and, or } = convertWhereClause(model, where);
+					let query = db$2.updateTable(model).set(values);
+					if (and) query = query.where((eb) => eb.and(and.map((expr) => expr(eb))));
+					if (or) query = query.where((eb) => eb.or(or.map((expr) => expr(eb))));
+					return await withReturning(values, query, model, where);
+				}),
+				updateMany: ({ model, where, update: values }) => withDb$1(async (db$2) => {
+					const { and, or } = convertWhereClause(model, where);
+					let query = db$2.updateTable(model).set(values);
+					if (and) query = query.where((eb) => eb.and(and.map((expr) => expr(eb))));
+					if (or) query = query.where((eb) => eb.or(or.map((expr) => expr(eb))));
+					return (await query.execute()).length;
+				}),
+				count: ({ model, where }) => withDb$1(async (db$2) => {
+					const { and, or } = convertWhereClause(model, where);
+					let query = db$2.selectFrom(model).select(db$2.fn.count("id").as("count"));
+					if (and) query = query.where((eb) => eb.and(and.map((expr) => expr(eb))));
+					if (or) query = query.where((eb) => eb.or(or.map((expr) => expr(eb))));
+					const res = await query.execute();
+					if (typeof res[0].count === "number") return res[0].count;
+					if (typeof res[0].count === "bigint") return Number(res[0].count);
+					return parseInt(res[0].count);
+				}),
+				delete: ({ model, where }) => withDb$1(async (db$2) => {
+					const { and, or } = convertWhereClause(model, where);
+					let query = db$2.deleteFrom(model);
+					if (and) query = query.where((eb) => eb.and(and.map((expr) => expr(eb))));
+					if (or) query = query.where((eb) => eb.or(or.map((expr) => expr(eb))));
+					await query.execute();
+				}),
+				deleteMany: ({ model, where }) => withDb$1(async (db$2) => {
+					const { and, or } = convertWhereClause(model, where);
+					let query = db$2.deleteFrom(model);
+					if (and) query = query.where((eb) => eb.and(and.map((expr) => expr(eb))));
+					if (or) query = query.where((eb) => eb.or(or.map((expr) => expr(eb))));
+					return (await query.execute()).length;
+				}),
+				options: config
+			};
+		};
+	};
+	let adapterOptions = null;
+	adapterOptions = {
+		config: {
+			adapterId: "kysely",
+			adapterName: "Kysely Adapter",
+			usePlural: config?.usePlural,
+			debugLogs: config?.debugLogs,
+			supportsBooleans: config?.type === "sqlite" || config?.type === "mssql" || config?.type === "mysql" || !config?.type ? false : true,
+			supportsDates: config?.type === "sqlite" || config?.type === "mssql" || !config?.type ? false : true,
+			supportsJSON: false,
+			transaction: config?.transaction ?? false ? (cb) => withDb((db$1) => db$1.transaction().execute(((trx) => {
+				return cb(require_adapter_factory.createAdapterFactory({
+					config: adapterOptions.config,
+					adapter: createCustomAdapter(trx)
+				})(lazyOptions));
+			}))) : false
+		},
+		adapter: createCustomAdapter(db)
+	};
+	const adapter = require_adapter_factory.createAdapterFactory(adapterOptions);
+	return (options) => {
+		lazyOptions = options;
+		return adapter(options);
+	};
+};
+
+//#endregion
+Object.defineProperty(exports, 'createKyselyAdapter', {
+  enumerable: true,
+  get: function () {
+    return createKyselyAdapter;
+  }
+});
+Object.defineProperty(exports, 'getKyselyDatabaseType', {
+  enumerable: true,
+  get: function () {
+    return getKyselyDatabaseType;
+  }
+});
+Object.defineProperty(exports, 'kyselyAdapter', {
+  enumerable: true,
+  get: function () {
+    return kyselyAdapter;
+  }
+});

package/dist/kysely-adapter-DRuoT_X8.mjs

@@ -0,0 +1,270 @@
+import { t as createAdapterFactory } from "./adapter-factory-BXei1QRX.mjs";
+import { isPromise } from "@faire-auth/core/static";
+import { Kysely, MssqlDialect, MysqlDialect, PostgresDialect, SqliteDialect } from "kysely";
+
+//#region src/adapters/kysely-adapter/dialect.ts
+function getKyselyDatabaseType(db) {
+	if (!db) return null;
+	if ("dialect" in db) return getKyselyDatabaseType(db.dialect);
+	if ("createDriver" in db) {
+		if (db instanceof SqliteDialect) return "sqlite";
+		if (db instanceof MysqlDialect) return "mysql";
+		if (db instanceof PostgresDialect) return "postgres";
+		if (db instanceof MssqlDialect) return "mssql";
+	}
+	if ("aggregate" in db) return "sqlite";
+	if ("getConnection" in db) return "mysql";
+	if ("connect" in db) return "postgres";
+	if ("fileControl" in db) return "sqlite";
+	if ("open" in db && "close" in db && "prepare" in db) return "sqlite";
+	return null;
+}
+const createKyselyAdapter = (config) => {
+	const db = config.database;
+	if (!db) return {
+		kysely: null,
+		databaseType: null,
+		transaction: void 0
+	};
+	if ("db" in db) return {
+		kysely: db.db,
+		databaseType: db.type,
+		transaction: db.transaction
+	};
+	if ("dialect" in db) return {
+		kysely: new Kysely({ dialect: db.dialect }),
+		databaseType: db.type,
+		transaction: db.transaction
+	};
+	let dialect = void 0;
+	const databaseType = getKyselyDatabaseType(db);
+	if ("createDriver" in db) dialect = db;
+	if ("aggregate" in db && !("createSession" in db)) dialect = new SqliteDialect({ database: db });
+	if ("getConnection" in db) dialect = new MysqlDialect(db);
+	if ("connect" in db) dialect = new PostgresDialect({ pool: db });
+	const toReturn = {
+		kysely: dialect ? new Kysely({ dialect }) : null,
+		databaseType,
+		transaction: void 0,
+		async initialize() {
+			if (toReturn.kysely == null) {
+				if ("fileControl" in db) {
+					console.log("found file control");
+					const { BunSqliteDialect } = await import("./bun-sqlite-dialect-CfkBo2v5.mjs");
+					dialect = new BunSqliteDialect({ database: db });
+				}
+				if ("createSession" in db && typeof window === "undefined") {
+					console.log("found create session");
+					let DatabaseSync = void 0;
+					try {
+						let nodeSqlite = "node:sqlite";
+						({DatabaseSync} = await import(
+							/* @vite-ignore */
+							/* webpackIgnore: true */
+							nodeSqlite
+));
+					} catch (error) {
+						console.log("caught");
+						if (error !== null && typeof error === "object" && "code" in error && error.code !== "ERR_UNKNOWN_BUILTIN_MODULE") throw error;
+					}
+					console.log("import dialect");
+					if (DatabaseSync && db instanceof DatabaseSync) {
+						const { NodeSqliteDialect } = await import("./node-sqlite-dialect-BfBzyOAg.mjs");
+						dialect = new NodeSqliteDialect({ database: db });
+					}
+				}
+				if (dialect) toReturn.kysely = new Kysely({ dialect });
+			}
+		}
+	};
+	return toReturn;
+};
+
+//#endregion
+//#region src/adapters/kysely-adapter/kysely-adapter.ts
+const withDbInit = (db, work) => async (fn) => {
+	const rdb = isPromise(db) ? await db : db;
+	if (work) work(rdb);
+	return fn(rdb);
+};
+const kyselyAdapter = (db, config) => {
+	let lazyOptions = null;
+	const withDb = withDbInit(db);
+	const createCustomAdapter = (db$1) => {
+		return ({ getFieldName }) => {
+			const withReturningInit = (db$2) => async (values, builder, model, where) => {
+				let res;
+				if (config?.type === "mysql") {
+					await builder.execute();
+					const field = values.id ? "id" : where.length > 0 && where[0]?.field ? where[0].field : "id";
+					if (!values.id && where.length === 0) {
+						res = await db$2.selectFrom(model).selectAll().orderBy(getFieldName({
+							model,
+							field
+						}), "desc").limit(1).executeTakeFirst();
+						return res;
+					}
+					const value = values[field] || where[0]?.value;
+					res = await db$2.selectFrom(model).selectAll().orderBy(getFieldName({
+						model,
+						field
+					}), "desc").where(getFieldName({
+						model,
+						field
+					}), "=", value).limit(1).executeTakeFirst();
+					return res;
+				}
+				if (config?.type === "mssql") {
+					res = await builder.outputAll("inserted").executeTakeFirst();
+					return res;
+				}
+				res = await builder.returningAll().executeTakeFirst();
+				return res;
+			};
+			let withReturning;
+			const withDb$1 = withDbInit(db$1, (db$2) => withReturning ??= withReturningInit(db$2));
+			function convertWhereClause(model, w) {
+				if (!w) return {
+					and: null,
+					or: null
+				};
+				const conditions = {
+					and: [],
+					or: []
+				};
+				w.forEach((condition) => {
+					let { field: _field, value: _value, operator = "=", connector = "AND" } = condition;
+					let value = _value;
+					let field = getFieldName({
+						model,
+						field: _field
+					});
+					const expr = (eb) => {
+						if (operator.toLowerCase() === "in") return eb(field, "in", Array.isArray(value) ? value : [value]);
+						if (operator.toLowerCase() === "not_in") return eb(field, "not in", Array.isArray(value) ? value : [value]);
+						if (operator === "contains") return eb(field, "like", `%${value}%`);
+						if (operator === "starts_with") return eb(field, "like", `${value}%`);
+						if (operator === "ends_with") return eb(field, "like", `%${value}`);
+						if (operator === "eq") return eb(field, "=", value);
+						if (operator === "ne") return eb(field, "<>", value);
+						if (operator === "gt") return eb(field, ">", value);
+						if (operator === "gte") return eb(field, ">=", value);
+						if (operator === "lt") return eb(field, "<", value);
+						if (operator === "lte") return eb(field, "<=", value);
+						return eb(field, operator, value);
+					};
+					if (connector === "OR") conditions.or.push(expr);
+					else conditions.and.push(expr);
+				});
+				return {
+					and: conditions.and.length ? conditions.and : null,
+					or: conditions.or.length ? conditions.or : null
+				};
+			}
+			return {
+				create: ({ data, model }) => withDb$1(async (db$2) => {
+					const builder = db$2.insertInto(model).values(data);
+					return await withReturning(data, builder, model, []);
+				}),
+				findOne: ({ model, where, select }) => withDb$1(async (db$2) => {
+					const { and, or } = convertWhereClause(model, where);
+					let query = db$2.selectFrom(model).selectAll();
+					if (and) query = query.where((eb) => eb.and(and.map((expr) => expr(eb))));
+					if (or) query = query.where((eb) => eb.or(or.map((expr) => expr(eb))));
+					const res = await query.executeTakeFirst();
+					if (!res) return null;
+					return res;
+				}),
+				findMany: ({ model, where, limit, offset, sortBy }) => withDb$1(async (db$2) => {
+					const { and, or } = convertWhereClause(model, where);
+					let query = db$2.selectFrom(model);
+					if (and) query = query.where((eb) => eb.and(and.map((expr) => expr(eb))));
+					if (or) query = query.where((eb) => eb.or(or.map((expr) => expr(eb))));
+					if (config?.type === "mssql") {
+						if (!offset) query = query.top(limit || 100);
+					} else query = query.limit(limit || 100);
+					if (sortBy) query = query.orderBy(getFieldName({
+						model,
+						field: sortBy.field
+					}), sortBy.direction);
+					if (offset) if (config?.type === "mssql") {
+						if (!sortBy) query = query.orderBy(getFieldName({
+							model,
+							field: "id"
+						}));
+						query = query.offset(offset).fetch(limit || 100);
+					} else query = query.offset(offset);
+					const res = await query.selectAll().execute();
+					if (!res) return [];
+					return res;
+				}),
+				update: ({ model, where, update: values }) => withDb$1(async (db$2) => {
+					const { and, or } = convertWhereClause(model, where);
+					let query = db$2.updateTable(model).set(values);
+					if (and) query = query.where((eb) => eb.and(and.map((expr) => expr(eb))));
+					if (or) query = query.where((eb) => eb.or(or.map((expr) => expr(eb))));
+					return await withReturning(values, query, model, where);
+				}),
+				updateMany: ({ model, where, update: values }) => withDb$1(async (db$2) => {
+					const { and, or } = convertWhereClause(model, where);
+					let query = db$2.updateTable(model).set(values);
+					if (and) query = query.where((eb) => eb.and(and.map((expr) => expr(eb))));
+					if (or) query = query.where((eb) => eb.or(or.map((expr) => expr(eb))));
+					return (await query.execute()).length;
+				}),
+				count: ({ model, where }) => withDb$1(async (db$2) => {
+					const { and, or } = convertWhereClause(model, where);
+					let query = db$2.selectFrom(model).select(db$2.fn.count("id").as("count"));
+					if (and) query = query.where((eb) => eb.and(and.map((expr) => expr(eb))));
+					if (or) query = query.where((eb) => eb.or(or.map((expr) => expr(eb))));
+					const res = await query.execute();
+					if (typeof res[0].count === "number") return res[0].count;
+					if (typeof res[0].count === "bigint") return Number(res[0].count);
+					return parseInt(res[0].count);
+				}),
+				delete: ({ model, where }) => withDb$1(async (db$2) => {
+					const { and, or } = convertWhereClause(model, where);
+					let query = db$2.deleteFrom(model);
+					if (and) query = query.where((eb) => eb.and(and.map((expr) => expr(eb))));
+					if (or) query = query.where((eb) => eb.or(or.map((expr) => expr(eb))));
+					await query.execute();
+				}),
+				deleteMany: ({ model, where }) => withDb$1(async (db$2) => {
+					const { and, or } = convertWhereClause(model, where);
+					let query = db$2.deleteFrom(model);
+					if (and) query = query.where((eb) => eb.and(and.map((expr) => expr(eb))));
+					if (or) query = query.where((eb) => eb.or(or.map((expr) => expr(eb))));
+					return (await query.execute()).length;
+				}),
+				options: config
+			};
+		};
+	};
+	let adapterOptions = null;
+	adapterOptions = {
+		config: {
+			adapterId: "kysely",
+			adapterName: "Kysely Adapter",
+			usePlural: config?.usePlural,
+			debugLogs: config?.debugLogs,
+			supportsBooleans: config?.type === "sqlite" || config?.type === "mssql" || config?.type === "mysql" || !config?.type ? false : true,
+			supportsDates: config?.type === "sqlite" || config?.type === "mssql" || !config?.type ? false : true,
+			supportsJSON: false,
+			transaction: config?.transaction ?? false ? (cb) => withDb((db$1) => db$1.transaction().execute(((trx) => {
+				return cb(createAdapterFactory({
+					config: adapterOptions.config,
+					adapter: createCustomAdapter(trx)
+				})(lazyOptions));
+			}))) : false
+		},
+		adapter: createCustomAdapter(db)
+	};
+	const adapter = createAdapterFactory(adapterOptions);
+	return (options) => {
+		lazyOptions = options;
+		return adapter(options);
+	};
+};
+
+//#endregion
+export { createKyselyAdapter as n, getKyselyDatabaseType as r, kyselyAdapter as t };