appos 0.1.0

package/build/lib/kysely-adapter-BTWfu5rn.mjs

@@ -0,0 +1,183 @@
+import "./esm-DPet4lFW.mjs";
+import { n as getKyselyDatabaseType, t as createKyselyAdapter } from "./dialect-BeMwdQoz-D41NdSow.mjs";
+import { t as createAdapterFactory } from "./adapter-factory-CLtf7vT5-CTKiMV2u.mjs";
+
+//#region node_modules/better-auth/dist/adapters/kysely-adapter/index.mjs
+const kyselyAdapter = (db, config) => {
+	let lazyOptions = null;
+	const createCustomAdapter = (db$1) => {
+		return ({ getFieldName }) => {
+			const withReturning = 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$1.selectFrom(model).selectAll().orderBy(getFieldName({
+							model,
+							field
+						}), "desc").limit(1).executeTakeFirst();
+						return res;
+					}
+					const value = values[field] || where[0]?.value;
+					res = await db$1.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;
+			};
+			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 {
+				async create({ data, model }) {
+					return await withReturning(data, db$1.insertInto(model).values(data), model, []);
+				},
+				async findOne({ model, where, select }) {
+					const { and, or } = convertWhereClause(model, where);
+					let query = db$1.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;
+				},
+				async findMany({ model, where, limit, offset, sortBy }) {
+					const { and, or } = convertWhereClause(model, where);
+					let query = db$1.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;
+				},
+				async update({ model, where, update: values }) {
+					const { and, or } = convertWhereClause(model, where);
+					let query = db$1.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);
+				},
+				async updateMany({ model, where, update: values }) {
+					const { and, or } = convertWhereClause(model, where);
+					let query = db$1.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;
+				},
+				async count({ model, where }) {
+					const { and, or } = convertWhereClause(model, where);
+					let query = db$1.selectFrom(model).select(db$1.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);
+				},
+				async delete({ model, where }) {
+					const { and, or } = convertWhereClause(model, where);
+					let query = db$1.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();
+				},
+				async deleteMany({ model, where }) {
+					const { and, or } = convertWhereClause(model, where);
+					let query = db$1.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,
+			supportsUUIDs: config?.type === "postgres" ? true : false,
+			transaction: config?.transaction ? (cb) => db.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, kyselyAdapter };