@kky42/pievo-server 2.4.14 → 3.0.0

package/.output/server/_ssr/bun-sqlite-dialect-BW9W1_Ps-DLIXocA0.mjs

@@ -1,162 +0,0 @@
-import { n as DefaultQueryCompiler, o as CompiledQuery, s as sql$1 } from "./auth-0AamrwHo.mjs";
-import { n as DEFAULT_MIGRATION_TABLE, t as DEFAULT_MIGRATION_LOCK_TABLE } from "./kysely-migration-tables-JkVUjPF_-bPAX9LR_.mjs";
-//#region node_modules/.nitro/vite/services/ssr/assets/bun-sqlite-dialect-BW9W1_Ps-DLIXocA0.js
-var BunSqliteAdapter = class {
-	get supportsCreateIfNotExists() {
-		return true;
-	}
-	get supportsTransactionalDdl() {
-		return false;
-	}
-	get supportsMultipleConnections() {
-		return false;
-	}
-	get supportsReturning() {
-		return true;
-	}
-	async acquireMigrationLock() {}
-	async releaseMigrationLock() {}
-	get supportsOutput() {
-		return true;
-	}
-};
-var BunSqliteDriver = class {
-	#config;
-	#connectionMutex = new ConnectionMutex();
-	#db;
-	#connection;
-	constructor(config) {
-		this.#config = { ...config };
-	}
-	async init() {
-		this.#db = this.#config.database;
-		this.#connection = new BunSqliteConnection(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 BunSqliteConnection = class {
-	#db;
-	constructor(db) {
-		this.#db = db;
-	}
-	executeQuery(compiledQuery) {
-		const { sql, parameters } = compiledQuery;
-		const stmt = this.#db.prepare(sql);
-		const params = parameters;
-		if (stmt.columnNames.length > 0) return Promise.resolve({ rows: stmt.all(...params) });
-		const { changes, lastInsertRowid } = stmt.run(...params);
-		return Promise.resolve({
-			rows: [],
-			numAffectedRows: BigInt(changes),
-			insertId: typeof lastInsertRowid === "bigint" ? lastInsertRowid : BigInt(lastInsertRowid)
-		});
-	}
-	async *streamQuery() {
-		throw new Error("Streaming query is not supported by SQLite driver.");
-	}
-};
-var ConnectionMutex = class {
-	#promise;
-	#resolve;
-	async lock() {
-		while (this.#promise !== void 0) 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 BunSqliteIntrospector = 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 #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$1`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: false,
-			isForeign: false
-		};
-	}
-};
-var BunSqliteQueryCompiler = class extends DefaultQueryCompiler {
-	getCurrentParameterPlaceholder() {
-		return "?";
-	}
-	getLeftIdentifierWrapper() {
-		return "\"";
-	}
-	getRightIdentifierWrapper() {
-		return "\"";
-	}
-	getAutoIncrement() {
-		return "autoincrement";
-	}
-};
-var BunSqliteDialect = class {
-	#config;
-	constructor(config) {
-		this.#config = { ...config };
-	}
-	createDriver() {
-		return new BunSqliteDriver(this.#config);
-	}
-	createQueryCompiler() {
-		return new BunSqliteQueryCompiler();
-	}
-	createAdapter() {
-		return new BunSqliteAdapter();
-	}
-	createIntrospector(db) {
-		return new BunSqliteIntrospector(db);
-	}
-};
-//#endregion
-export { BunSqliteDialect };

package/.output/server/_ssr/core-RrmWoKne.mjs

@@ -1,5 +0,0 @@
-//#region node_modules/.nitro/vite/services/ssr/assets/core-RrmWoKne.js
-var core_default = {};
-throw new Error(`Could not resolve "@opentelemetry/api" imported by "@better-auth/core". Is it installed?`);
-//#endregion
-export { core_default as default };

package/.output/server/_ssr/d1-sqlite-dialect-BLC8LXE6-BoFMIPr_.mjs

@@ -1,112 +0,0 @@
-import { a as SqliteQueryCompiler, i as SqliteAdapter } from "./auth-0AamrwHo.mjs";
-import { n as DEFAULT_MIGRATION_TABLE, t as DEFAULT_MIGRATION_LOCK_TABLE } from "./kysely-migration-tables-JkVUjPF_-bPAX9LR_.mjs";
-//#region node_modules/.nitro/vite/services/ssr/assets/d1-sqlite-dialect-BLC8LXE6-BoFMIPr_.js
-var D1SqliteAdapter = class extends SqliteAdapter {};
-var D1SqliteDriver = class {
-	#config;
-	#connection;
-	constructor(config) {
-		this.#config = { ...config };
-	}
-	async init() {
-		this.#connection = new D1SqliteConnection(this.#config.database);
-		if (this.#config.onCreateConnection) await this.#config.onCreateConnection(this.#connection);
-	}
-	async acquireConnection() {
-		return this.#connection;
-	}
-	async beginTransaction() {
-		throw new Error("D1 does not support interactive transactions. Use the D1 batch() API instead.");
-	}
-	async commitTransaction() {
-		throw new Error("D1 does not support interactive transactions. Use the D1 batch() API instead.");
-	}
-	async rollbackTransaction() {
-		throw new Error("D1 does not support interactive transactions. Use the D1 batch() API instead.");
-	}
-	async releaseConnection() {}
-	async destroy() {}
-};
-var D1SqliteConnection = class {
-	#db;
-	constructor(db) {
-		this.#db = db;
-	}
-	async executeQuery(compiledQuery) {
-		const results = await this.#db.prepare(compiledQuery.sql).bind(...compiledQuery.parameters).all();
-		const numAffectedRows = results.meta.changes != null ? BigInt(results.meta.changes) : void 0;
-		return {
-			insertId: results.meta.last_row_id === void 0 || results.meta.last_row_id === null ? void 0 : BigInt(results.meta.last_row_id),
-			rows: results?.results || [],
-			numAffectedRows
-		};
-	}
-	async *streamQuery() {
-		throw new Error("D1 does not support streaming queries.");
-	}
-};
-var D1SqliteIntrospector = class {
-	#db;
-	#d1;
-	constructor(db, d1) {
-		this.#db = db;
-		this.#d1 = d1;
-	}
-	async getSchemas() {
-		return [];
-	}
-	async getTables(options = { withInternalKyselyTables: false }) {
-		let query = this.#db.selectFrom("sqlite_master").where("type", "in", ["table", "view"]).where("name", "not like", "sqlite_%").where("name", "not like", "_cf_%").select([
-			"name",
-			"type",
-			"sql"
-		]).$castTo();
-		if (!options.withInternalKyselyTables) query = query.where("name", "!=", DEFAULT_MIGRATION_TABLE).where("name", "!=", DEFAULT_MIGRATION_LOCK_TABLE);
-		const tables = await query.execute();
-		if (tables.length === 0) return [];
-		const statements = tables.map((table) => this.#d1.prepare("SELECT * FROM pragma_table_info(?)").bind(table.name));
-		const batchResults = await this.#d1.batch(statements);
-		return tables.map((table, index) => {
-			const columnInfo = batchResults[index]?.results ?? [];
-			let autoIncrementCol = table.sql?.split(/[(),]/)?.find((it) => it.toLowerCase().includes("autoincrement"))?.split(/\s+/)?.filter(Boolean)?.[0]?.replace(/["`]/g, "");
-			if (!autoIncrementCol) {
-				const pkCols = columnInfo.filter((r) => r.pk > 0);
-				const singlePk = pkCols.length === 1 ? pkCols[0] : void 0;
-				if (singlePk && singlePk.type.toLowerCase() === "integer") autoIncrementCol = singlePk.name;
-			}
-			return {
-				name: table.name,
-				isView: table.type === "view",
-				isForeign: false,
-				columns: columnInfo.map((col) => ({
-					name: col.name,
-					dataType: col.type,
-					isNullable: !col.notnull,
-					isAutoIncrementing: col.name === autoIncrementCol,
-					hasDefaultValue: col.dflt_value != null
-				}))
-			};
-		});
-	}
-};
-var D1SqliteQueryCompiler = class extends SqliteQueryCompiler {};
-var D1SqliteDialect = class {
-	#config;
-	constructor(config) {
-		this.#config = { ...config };
-	}
-	createDriver() {
-		return new D1SqliteDriver(this.#config);
-	}
-	createQueryCompiler() {
-		return new D1SqliteQueryCompiler();
-	}
-	createAdapter() {
-		return new D1SqliteAdapter();
-	}
-	createIntrospector(db) {
-		return new D1SqliteIntrospector(db, this.#config.database);
-	}
-};
-//#endregion
-export { D1SqliteDialect };

package/.output/server/_ssr/db-BzvMQ2kx.mjs

@@ -1,2 +0,0 @@
-import { N as db } from "./loopTags-CXx5UdGf.mjs";
-export { db };

package/.output/server/_ssr/dist-ClzqkwxD.mjs

@@ -1,342 +0,0 @@
-import { _ as logger, o as createAdapterFactory } from "./factory-ixUjZqJn.mjs";
-//#region node_modules/.nitro/vite/services/ssr/assets/dist-ClzqkwxD.js
-/**
-* Case-insensitive in-memory comparison helpers.
-* Used when evaluating where clauses in the memory adapter.
-*/
-function insensitiveCompare(a, b) {
-	if (typeof a === "string" && typeof b === "string") return a.toLowerCase() === b.toLowerCase();
-	return a === b;
-}
-function insensitiveIn(recordVal, values) {
-	if (typeof recordVal !== "string") return values.includes(recordVal);
-	return values.some((v) => typeof v === "string" && recordVal.toLowerCase() === v.toLowerCase());
-}
-function insensitiveNotIn(recordVal, values) {
-	return !insensitiveIn(recordVal, values);
-}
-function insensitiveContains(recordVal, value) {
-	if (typeof recordVal !== "string" || typeof value !== "string") return false;
-	return recordVal.toLowerCase().includes(value.toLowerCase());
-}
-function insensitiveStartsWith(recordVal, value) {
-	if (typeof recordVal !== "string" || typeof value !== "string") return false;
-	return recordVal.toLowerCase().startsWith(value.toLowerCase());
-}
-function insensitiveEndsWith(recordVal, value) {
-	if (typeof recordVal !== "string" || typeof value !== "string") return false;
-	return recordVal.toLowerCase().endsWith(value.toLowerCase());
-}
-/**
-* Index a table's rows by their `id` for row-level reconciliation. Every
-* better-auth row carries an `id` (the adapter's join logic already keys on
-* `record.id`), so the id is a stable identity for the three-way merge.
-*/
-function indexById(rows) {
-	const byId = /* @__PURE__ */ new Map();
-	for (const row of rows) byId.set(row.id, row);
-	return byId;
-}
-/**
-* Commit a transaction onto the live database with a three-way merge so a
-* concurrent write that interleaved at an `await` point survives.
-*
-* `base` is the snapshot taken when the transaction started; `clone` is that
-* snapshot after the transaction mutated it; `target` is the live database as
-* it stands now (possibly carrying concurrent writes). Replaying only the
-* `base -> clone` delta onto `target` applies the transaction's own creates,
-* updates, and deletes without disturbing rows or tables the transaction never
-* touched. A row the transaction did not change keeps the live version, so a
-* concurrent edit to a different row is preserved. A row the transaction did
-* change wins last-writer-wins over a concurrent edit to the same row, which is
-* acceptable for an in-memory development adapter; isolation is guaranteed only
-* at row/table granularity.
-*
-* `target` is mutated in place so any reference held elsewhere (for example the
-* `db` object the caller passed to `memoryAdapter`) stays valid.
-*/
-function mergeTransactionInto(target, base, clone) {
-	const models = new Set([...Object.keys(base), ...Object.keys(clone)]);
-	for (const model of models) {
-		if (!(model in clone)) {
-			delete target[model];
-			continue;
-		}
-		const baseById = indexById(base[model] ?? []);
-		const cloneRows = clone[model] ?? [];
-		const cloneById = indexById(cloneRows);
-		const liveRows = target[model] ?? [];
-		const merged = [];
-		const placed = /* @__PURE__ */ new Set();
-		for (const liveRow of liveRows) {
-			const id = liveRow.id;
-			const baseRow = baseById.get(id);
-			const cloneRow = cloneById.get(id);
-			if (baseRow !== void 0 && cloneRow === void 0) continue;
-			if (cloneRow !== void 0 && rowChanged(baseRow, cloneRow)) merged.push(cloneRow);
-			else merged.push(liveRow);
-			placed.add(id);
-		}
-		for (const cloneRow of cloneRows) if (!baseById.has(cloneRow.id) && !placed.has(cloneRow.id)) merged.push(cloneRow);
-		target[model] = merged;
-	}
-}
-/**
-* Whether the transaction mutated a row, comparing its pre-transaction
-* snapshot to its post-transaction state. Rows hold scalar columns and
-* adapter-serializable values, so JSON equality reliably tells a
-* transaction-made edit apart from an untouched row.
-*/
-function rowChanged(baseRow, cloneRow) {
-	if (baseRow === void 0) return true;
-	return JSON.stringify(baseRow) !== JSON.stringify(cloneRow);
-}
-var memoryAdapter = (db, config) => {
-	let lazyOptions = null;
-	/**
-	* Build an adapter factory whose operations read and write `activeDb`.
-	* The non-transactional adapter targets the live `db`. A transaction
-	* targets an isolated clone so its uncommitted writes are invisible to
-	* concurrent operations against the live `db`. A failed transaction leaves
-	* the live `db` untouched, and a committed one replays only its own
-	* row/table changes, so a concurrent write that interleaved at an `await`
-	* point survives either outcome. Isolation is at row/table granularity:
-	* the in-memory adapter does not serialize writes, so two operations that
-	* edit the same row resolve last-writer-wins. It is built for development
-	* and tests, not production concurrency control.
-	*/
-	const buildAdapterFactory = (activeDb) => createAdapterFactory({
-		config: {
-			adapterId: "memory",
-			adapterName: "Memory Adapter",
-			usePlural: false,
-			debugLogs: config?.debugLogs || false,
-			supportsArrays: true,
-			customTransformInput(props) {
-				if (props.options.advanced?.database?.generateId === "serial" && props.field === "id" && props.action === "create") return activeDb[props.model].length + 1;
-				return props.data;
-			},
-			transaction: async (cb) => {
-				const base = structuredClone(activeDb);
-				const clone = structuredClone(activeDb);
-				const result = await cb(buildAdapterFactory(clone)(lazyOptions));
-				mergeTransactionInto(activeDb, base, clone);
-				return result;
-			}
-		},
-		adapter: ({ getFieldName, getDefaultFieldName, 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, select) {
-				const baseRecords = (() => {
-					const table = activeDb[model];
-					if (!table) {
-						logger.error(`[MemoryAdapter] Model ${model} not found in the DB`, Object.keys(activeDb));
-						throw new Error(`Model ${model} not found`);
-					}
-					const evalClause = (record, clause) => {
-						const { field, value, operator, mode = "sensitive" } = clause;
-						const isInsensitive = mode === "insensitive" && (typeof value === "string" || Array.isArray(value) && value.every((v) => typeof v === "string"));
-						switch (operator) {
-							case "in":
-								if (!Array.isArray(value)) throw new Error("Value must be an array");
-								if (isInsensitive) return insensitiveIn(record[field], value);
-								return value.includes(record[field]);
-							case "not_in":
-								if (!Array.isArray(value)) throw new Error("Value must be an array");
-								if (isInsensitive) return insensitiveNotIn(record[field], value);
-								return !value.includes(record[field]);
-							case "contains":
-								if (isInsensitive) return insensitiveContains(record[field], value);
-								return record[field]?.includes(value);
-							case "starts_with":
-								if (isInsensitive) return insensitiveStartsWith(record[field], value);
-								return record[field].startsWith(value);
-							case "ends_with":
-								if (isInsensitive) return insensitiveEndsWith(record[field], value);
-								return record[field].endsWith(value);
-							case "ne": return isInsensitive ? !insensitiveCompare(record[field], value) : 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:
-								if (isInsensitive) return insensitiveCompare(record[field], value);
-								if (value === null) return record[field] == null;
-								return record[field] === value;
-						}
-					};
-					let records = table.filter((record) => {
-						if (!where.length || where.length === 0) return true;
-						let result = evalClause(record, where[0]);
-						for (const clause of where) {
-							const clauseResult = evalClause(record, clause);
-							if (clause.connector === "OR") result = result || clauseResult;
-							else result = result && clauseResult;
-						}
-						return result;
-					});
-					if (select?.length && select.length > 0) records = records.map((record) => Object.fromEntries(Object.entries(record).filter(([key]) => select.includes(getDefaultFieldName({
-						model,
-						field: key
-					})))));
-					return records;
-				})();
-				if (!join) return baseRecords;
-				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 = activeDb[joinModelName];
-						if (!joinTable) {
-							logger.error(`[MemoryAdapter] JoinOption model ${joinModelName} not found in the DB`, Object.keys(activeDb));
-							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?.generateId === "serial") data.id = activeDb[getModelName(model)].length + 1;
-					if (!activeDb[model]) activeDb[model] = [];
-					activeDb[model].push(data);
-					return data;
-				},
-				findOne: async ({ model, where, select, join }) => {
-					const res = convertWhereClause(where, model, join, select);
-					if (join) {
-						const resArray = res;
-						if (!resArray.length) return null;
-						return resArray[0];
-					}
-					return res[0] || null;
-				},
-				findMany: async ({ model, where, sortBy, limit, select, offset, join }) => {
-					const res = convertWhereClause(where || [], model, join, select);
-					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 activeDb[model].length;
-				},
-				update: async ({ model, where, update }) => {
-					if (where.length === 0) return null;
-					const res = convertWhereClause(where, model);
-					res.forEach((record) => {
-						Object.assign(record, update);
-					});
-					return res[0] || null;
-				},
-				delete: async ({ model, where }) => {
-					if (where.length === 0) return;
-					const table = activeDb[model];
-					const res = convertWhereClause(where, model);
-					activeDb[model] = table.filter((record) => !res.includes(record));
-				},
-				deleteMany: async ({ model, where }) => {
-					const table = activeDb[model];
-					const res = convertWhereClause(where, model);
-					let count = 0;
-					activeDb[model] = table.filter((record) => {
-						if (res.includes(record)) {
-							count++;
-							return false;
-						}
-						return !res.includes(record);
-					});
-					return count;
-				},
-				consumeOne: async ({ model, where }) => {
-					const table = activeDb[model];
-					const target = convertWhereClause(where, model)[0];
-					if (!target) return null;
-					activeDb[model] = table.filter((record) => record !== target);
-					return target;
-				},
-				incrementOne: async ({ model, where, increment, set }) => {
-					const target = convertWhereClause(where, model)[0];
-					if (!target) return null;
-					for (const [field, delta] of Object.entries(increment)) target[field] = (typeof target[field] === "number" ? target[field] : 0) + delta;
-					if (set) Object.assign(target, set);
-					return target;
-				},
-				updateMany: async ({ model, where, update }) => {
-					const res = convertWhereClause(where, model);
-					res.forEach((record) => {
-						Object.assign(record, update);
-					});
-					return res.length;
-				}
-			};
-		}
-	});
-	const adapterCreator = buildAdapterFactory(db);
-	return (options) => {
-		lazyOptions = options;
-		return adapterCreator(options);
-	};
-};
-//#endregion
-export { memoryAdapter };