appos 0.3.5-0 → 0.3.7-0

package/dist/exports/api/kysely-adapter-CmP2TbkS.mjs

@@ -0,0 +1,296 @@
+import { t as createAdapterFactory } from "./adapter-C2mMJKvG.mjs";
+import { l as sql } from "./esm-_hkVMulx.mjs";
+import { n as getKyselyDatabaseType, t as createKyselyAdapter } from "./dialect-CUUD24Ge.mjs";
+
+//#region ../../node_modules/.bun/better-auth@1.4.7+f768ad5b9455517d/node_modules/better-auth/dist/adapters/kysely-adapter/kysely-adapter.mjs
+const kyselyAdapter = (db, config) => {
+	let lazyOptions = null;
+	const createCustomAdapter = (db$1) => {
+		return ({ getFieldName, schema, getDefaultFieldName, getDefaultModelName, getFieldAttributes, getModelName }) => {
+			const selectAllJoins = (join) => {
+				const allSelects = [];
+				const allSelectsStr = [];
+				if (join) for (const [joinModel, _] of Object.entries(join)) {
+					const fields = schema[getDefaultModelName(joinModel)]?.fields;
+					const [_joinModelSchema, joinModelName] = joinModel.includes(".") ? joinModel.split(".") : [void 0, joinModel];
+					if (!fields) continue;
+					fields.id = { type: "string" };
+					for (const [field, fieldAttr] of Object.entries(fields)) {
+						allSelects.push(sql`${sql.ref(`join_${joinModelName}`)}.${sql.ref(fieldAttr.fieldName || field)} as ${sql.ref(`_joined_${joinModelName}_${fieldAttr.fieldName || field}`)}`);
+						allSelectsStr.push({
+							joinModel,
+							joinModelRef: joinModelName,
+							fieldName: fieldAttr.fieldName || field
+						});
+					}
+				}
+				return {
+					allSelectsStr,
+					allSelects
+				};
+			};
+			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) => {
+						const f = `${model}.${field}`;
+						if (operator.toLowerCase() === "in") return eb(f, "in", Array.isArray(value) ? value : [value]);
+						if (operator.toLowerCase() === "not_in") return eb(f, "not in", Array.isArray(value) ? value : [value]);
+						if (operator === "contains") return eb(f, "like", `%${value}%`);
+						if (operator === "starts_with") return eb(f, "like", `${value}%`);
+						if (operator === "ends_with") return eb(f, "like", `%${value}`);
+						if (operator === "eq") return eb(f, "=", value);
+						if (operator === "ne") return eb(f, "<>", value);
+						if (operator === "gt") return eb(f, ">", value);
+						if (operator === "gte") return eb(f, ">=", value);
+						if (operator === "lt") return eb(f, "<", value);
+						if (operator === "lte") return eb(f, "<=", value);
+						return eb(f, 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
+				};
+			}
+			function processJoinedResults(rows, joinConfig, allSelectsStr) {
+				if (!joinConfig || !rows.length) return rows;
+				const groupedByMainId = /* @__PURE__ */ new Map();
+				for (const currentRow of rows) {
+					const mainModelFields = {};
+					const joinedModelFields = {};
+					for (const [joinModel] of Object.entries(joinConfig)) joinedModelFields[getModelName(joinModel)] = {};
+					for (const [key, value] of Object.entries(currentRow)) {
+						const keyStr = String(key);
+						let assigned = false;
+						for (const { joinModel, fieldName, joinModelRef } of allSelectsStr) if (keyStr === `_joined_${joinModelRef}_${fieldName}`) {
+							joinedModelFields[getModelName(joinModel)][getFieldName({
+								model: joinModel,
+								field: fieldName
+							})] = value;
+							assigned = true;
+							break;
+						}
+						if (!assigned) mainModelFields[key] = value;
+					}
+					const mainId = mainModelFields.id;
+					if (!mainId) continue;
+					if (!groupedByMainId.has(mainId)) {
+						const entry$1 = { ...mainModelFields };
+						for (const [joinModel, joinAttr] of Object.entries(joinConfig)) entry$1[getModelName(joinModel)] = joinAttr.relation === "one-to-one" ? null : [];
+						groupedByMainId.set(mainId, entry$1);
+					}
+					const entry = groupedByMainId.get(mainId);
+					for (const [joinModel, joinAttr] of Object.entries(joinConfig)) {
+						const isUnique = joinAttr.relation === "one-to-one";
+						const limit = joinAttr.limit ?? 100;
+						const joinedObj = joinedModelFields[getModelName(joinModel)];
+						const hasData = joinedObj && Object.keys(joinedObj).length > 0 && Object.values(joinedObj).some((value) => value !== null && value !== void 0);
+						if (isUnique) entry[getModelName(joinModel)] = hasData ? joinedObj : null;
+						else {
+							const joinModelName = getModelName(joinModel);
+							if (Array.isArray(entry[joinModelName]) && hasData) {
+								if (entry[joinModelName].length >= limit) continue;
+								const idFieldName = getFieldName({
+									model: joinModel,
+									field: "id"
+								});
+								const joinedId = joinedObj[idFieldName];
+								if (joinedId) {
+									if (!entry[joinModelName].some((item) => item[idFieldName] === joinedId) && entry[joinModelName].length < limit) entry[joinModelName].push(joinedObj);
+								} else if (entry[joinModelName].length < limit) entry[joinModelName].push(joinedObj);
+							}
+						}
+					}
+				}
+				let result = Array.from(groupedByMainId.values());
+				for (const entry of result) for (const [joinModel, joinAttr] of Object.entries(joinConfig)) if (joinAttr.relation !== "one-to-one") {
+					const joinModelName = getModelName(joinModel);
+					if (Array.isArray(entry[joinModelName])) {
+						const limit = joinAttr.limit ?? 100;
+						if (entry[joinModelName].length > limit) entry[joinModelName] = entry[joinModelName].slice(0, limit);
+					}
+				}
+				return result;
+			}
+			return {
+				async create({ data, model }) {
+					return await withReturning(data, db$1.insertInto(model).values(data), model, []);
+				},
+				async findOne({ model, where, select, join }) {
+					const { and, or } = convertWhereClause(model, where);
+					let query = db$1.selectFrom((eb) => {
+						let b = eb.selectFrom(model);
+						if (and) b = b.where((eb$1) => eb$1.and(and.map((expr) => expr(eb$1))));
+						if (or) b = b.where((eb$1) => eb$1.or(or.map((expr) => expr(eb$1))));
+						return b.selectAll().as("primary");
+					}).selectAll("primary");
+					if (join) for (const [joinModel, joinAttr] of Object.entries(join)) {
+						const [_joinModelSchema, joinModelName] = joinModel.includes(".") ? joinModel.split(".") : [void 0, joinModel];
+						query = query.leftJoin(`${joinModel} as join_${joinModelName}`, (join$1) => join$1.onRef(`join_${joinModelName}.${joinAttr.on.to}`, "=", `primary.${joinAttr.on.from}`));
+					}
+					const { allSelectsStr, allSelects } = selectAllJoins(join);
+					query = query.select(allSelects);
+					const res = await query.execute();
+					if (!res || !Array.isArray(res) || res.length === 0) return null;
+					const row = res[0];
+					if (join) return processJoinedResults(res, join, allSelectsStr)[0];
+					return row;
+				},
+				async findMany({ model, where, limit, offset, sortBy, join }) {
+					const { and, or } = convertWhereClause(model, where);
+					let query = db$1.selectFrom((eb) => {
+						let b = eb.selectFrom(model);
+						if (config?.type === "mssql") {
+							if (offset !== void 0) {
+								if (!sortBy) b = b.orderBy(getFieldName({
+									model,
+									field: "id"
+								}));
+								b = b.offset(offset).fetch(limit || 100);
+							} else if (limit !== void 0) b = b.top(limit);
+						} else {
+							if (limit !== void 0) b = b.limit(limit);
+							if (offset !== void 0) b = b.offset(offset);
+						}
+						if (sortBy?.field) b = b.orderBy(`${getFieldName({
+							model,
+							field: sortBy.field
+						})}`, sortBy.direction);
+						if (and) b = b.where((eb$1) => eb$1.and(and.map((expr) => expr(eb$1))));
+						if (or) b = b.where((eb$1) => eb$1.or(or.map((expr) => expr(eb$1))));
+						return b.selectAll().as("primary");
+					}).selectAll("primary");
+					if (join) for (const [joinModel, joinAttr] of Object.entries(join)) {
+						const [_joinModelSchema, joinModelName] = joinModel.includes(".") ? joinModel.split(".") : [void 0, joinModel];
+						query = query.leftJoin(`${joinModel} as join_${joinModelName}`, (join$1) => join$1.onRef(`join_${joinModelName}.${joinAttr.on.to}`, "=", `primary.${joinAttr.on.from}`));
+					}
+					const { allSelectsStr, allSelects } = selectAllJoins(join);
+					query = query.select(allSelects);
+					if (sortBy?.field) query = query.orderBy(`${getFieldName({
+						model,
+						field: sortBy.field
+					})}`, sortBy.direction);
+					const res = await query.execute();
+					if (!res) return [];
+					if (join) return processJoinedResults(res, join, allSelectsStr);
+					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))));
+					const res = (await query.executeTakeFirst()).numUpdatedRows;
+					return res > Number.MAX_SAFE_INTEGER ? Number.MAX_SAFE_INTEGER : Number(res);
+				},
+				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))));
+					const res = (await query.executeTakeFirst()).numDeletedRows;
+					return res > Number.MAX_SAFE_INTEGER ? Number.MAX_SAFE_INTEGER : Number(res);
+				},
+				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: config?.type === "postgres" ? true : false,
+			supportsArrays: 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 };

package/dist/exports/api/memory-adapter-BzhRhLFK.mjs

@@ -0,0 +1,212 @@
+import { t as createAdapterFactory, v as logger } from "./adapter-C2mMJKvG.mjs";
+import "./env-CwT3zhez.mjs";
+
+//#region ../../node_modules/.bun/better-auth@1.4.7+f768ad5b9455517d/node_modules/better-auth/dist/adapters/memory-adapter/memory-adapter.mjs
+const memoryAdapter = (db, config) => {
+	let lazyOptions = null;
+	let adapterCreator = createAdapterFactory({
+		config: {
+			adapterId: "memory",
+			adapterName: "Memory Adapter",
+			usePlural: false,
+			debugLogs: config?.debugLogs || false,
+			customTransformInput(props) {
+				if ((props.options.advanced?.database?.useNumberId || props.options.advanced?.database?.generateId === "serial") && props.field === "id" && props.action === "create") return db[props.model].length + 1;
+				return props.data;
+			},
+			transaction: async (cb) => {
+				let clone = structuredClone(db);
+				try {
+					return await cb(adapterCreator(lazyOptions));
+				} catch (error) {
+					Object.keys(db).forEach((key) => {
+						db[key] = clone[key];
+					});
+					throw error;
+				}
+			}
+		},
+		adapter: ({ getFieldName, options, getModelName }) => {
+			const applySortToRecords = (records, sortBy, model) => {
+				if (!sortBy) return records;
+				return records.sort((a, b) => {
+					const field = getFieldName({
+						model,
+						field: sortBy.field
+					});
+					const aValue = a[field];
+					const bValue = b[field];
+					let comparison = 0;
+					if (aValue == null && bValue == null) comparison = 0;
+					else if (aValue == null) comparison = -1;
+					else if (bValue == null) comparison = 1;
+					else if (typeof aValue === "string" && typeof bValue === "string") comparison = aValue.localeCompare(bValue);
+					else if (aValue instanceof Date && bValue instanceof Date) comparison = aValue.getTime() - bValue.getTime();
+					else if (typeof aValue === "number" && typeof bValue === "number") comparison = aValue - bValue;
+					else if (typeof aValue === "boolean" && typeof bValue === "boolean") comparison = aValue === bValue ? 0 : aValue ? 1 : -1;
+					else comparison = String(aValue).localeCompare(String(bValue));
+					return sortBy.direction === "asc" ? comparison : -comparison;
+				});
+			};
+			function convertWhereClause(where, model, join) {
+				const execute = (where$1, model$1) => {
+					const table = db[model$1];
+					if (!table) {
+						logger.error(`[MemoryAdapter] Model ${model$1} not found in the DB`, Object.keys(db));
+						throw new Error(`Model ${model$1} not found`);
+					}
+					const evalClause = (record, clause) => {
+						const { field, value, operator } = clause;
+						switch (operator) {
+							case "in":
+								if (!Array.isArray(value)) throw new Error("Value must be an array");
+								return value.includes(record[field]);
+							case "not_in":
+								if (!Array.isArray(value)) throw new Error("Value must be an array");
+								return !value.includes(record[field]);
+							case "contains": return record[field].includes(value);
+							case "starts_with": return record[field].startsWith(value);
+							case "ends_with": return record[field].endsWith(value);
+							case "ne": return record[field] !== value;
+							case "gt": return value != null && Boolean(record[field] > value);
+							case "gte": return value != null && Boolean(record[field] >= value);
+							case "lt": return value != null && Boolean(record[field] < value);
+							case "lte": return value != null && Boolean(record[field] <= value);
+							default: return record[field] === value;
+						}
+					};
+					return table.filter((record) => {
+						if (!where$1.length || where$1.length === 0) return true;
+						let result = evalClause(record, where$1[0]);
+						for (const clause of where$1) {
+							const clauseResult = evalClause(record, clause);
+							if (clause.connector === "OR") result = result || clauseResult;
+							else result = result && clauseResult;
+						}
+						return result;
+					});
+				};
+				if (!join) return execute(where, model);
+				const baseRecords = execute(where, model);
+				const grouped = /* @__PURE__ */ new Map();
+				const seenIds = /* @__PURE__ */ new Map();
+				for (const baseRecord of baseRecords) {
+					const baseId = String(baseRecord.id);
+					if (!grouped.has(baseId)) {
+						const nested = { ...baseRecord };
+						for (const [joinModel, joinAttr] of Object.entries(join)) {
+							const joinModelName = getModelName(joinModel);
+							if (joinAttr.relation === "one-to-one") nested[joinModelName] = null;
+							else {
+								nested[joinModelName] = [];
+								seenIds.set(`${baseId}-${joinModel}`, /* @__PURE__ */ new Set());
+							}
+						}
+						grouped.set(baseId, nested);
+					}
+					const nestedEntry = grouped.get(baseId);
+					for (const [joinModel, joinAttr] of Object.entries(join)) {
+						const joinModelName = getModelName(joinModel);
+						const joinTable = db[joinModelName];
+						if (!joinTable) {
+							logger.error(`[MemoryAdapter] JoinOption model ${joinModelName} not found in the DB`, Object.keys(db));
+							throw new Error(`JoinOption model ${joinModelName} not found`);
+						}
+						const matchingRecords = joinTable.filter((joinRecord) => joinRecord[joinAttr.on.to] === baseRecord[joinAttr.on.from]);
+						if (joinAttr.relation === "one-to-one") nestedEntry[joinModelName] = matchingRecords[0] || null;
+						else {
+							const seenSet = seenIds.get(`${baseId}-${joinModel}`);
+							const limit = joinAttr.limit ?? 100;
+							let count = 0;
+							for (const matchingRecord of matchingRecords) {
+								if (count >= limit) break;
+								if (!seenSet.has(matchingRecord.id)) {
+									nestedEntry[joinModelName].push(matchingRecord);
+									seenSet.add(matchingRecord.id);
+									count++;
+								}
+							}
+						}
+					}
+				}
+				return Array.from(grouped.values());
+			}
+			return {
+				create: async ({ model, data }) => {
+					if (options.advanced?.database?.useNumberId || options.advanced?.database?.generateId === "serial") data.id = db[getModelName(model)].length + 1;
+					if (!db[model]) db[model] = [];
+					db[model].push(data);
+					return data;
+				},
+				findOne: async ({ model, where, join }) => {
+					const res = convertWhereClause(where, model, join);
+					if (join) {
+						const resArray = res;
+						if (!resArray.length) return null;
+						return resArray[0];
+					}
+					return res[0] || null;
+				},
+				findMany: async ({ model, where, sortBy, limit, offset, join }) => {
+					let res = convertWhereClause(where || [], model, join);
+					if (join) {
+						const resArray = res;
+						if (!resArray.length) return [];
+						applySortToRecords(resArray, sortBy, model);
+						let paginatedRecords = resArray;
+						if (offset !== void 0) paginatedRecords = paginatedRecords.slice(offset);
+						if (limit !== void 0) paginatedRecords = paginatedRecords.slice(0, limit);
+						return paginatedRecords;
+					}
+					let table = applySortToRecords(res, sortBy, model);
+					if (offset !== void 0) table = table.slice(offset);
+					if (limit !== void 0) table = table.slice(0, limit);
+					return table || [];
+				},
+				count: async ({ model, where }) => {
+					if (where) return convertWhereClause(where, model).length;
+					return db[model].length;
+				},
+				update: async ({ model, where, update }) => {
+					const res = convertWhereClause(where, model);
+					res.forEach((record) => {
+						Object.assign(record, update);
+					});
+					return res[0] || null;
+				},
+				delete: async ({ model, where }) => {
+					const table = db[model];
+					const res = convertWhereClause(where, model);
+					db[model] = table.filter((record) => !res.includes(record));
+				},
+				deleteMany: async ({ model, where }) => {
+					const table = db[model];
+					const res = convertWhereClause(where, model);
+					let count = 0;
+					db[model] = table.filter((record) => {
+						if (res.includes(record)) {
+							count++;
+							return false;
+						}
+						return !res.includes(record);
+					});
+					return count;
+				},
+				updateMany({ model, where, update }) {
+					const res = convertWhereClause(where, model);
+					res.forEach((record) => {
+						Object.assign(record, update);
+					});
+					return res[0] || null;
+				}
+			};
+		}
+	});
+	return (options) => {
+		lazyOptions = options;
+		return adapterCreator(options);
+	};
+};
+
+//#endregion
+export { memoryAdapter };

package/dist/exports/api/node-sqlite-dialect-Bl5suBxl.mjs

@@ -0,0 +1,155 @@
+import { a as DEFAULT_MIGRATION_LOCK_TABLE, c as DefaultQueryCompiler, l as sql, o as DEFAULT_MIGRATION_TABLE, s as CompiledQuery } from "./esm-_hkVMulx.mjs";
+
+//#region ../../node_modules/.bun/better-auth@1.4.7+f768ad5b9455517d/node_modules/better-auth/dist/adapters/kysely-adapter/node-sqlite-dialect.mjs
+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 { NodeSqliteDialect };