@nextlyhq/adapter-sqlite 0.0.2-alpha.72 → 0.0.2-alpha.74

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { DrizzleAdapter } from "@nextlyhq/adapter-drizzle";
-import { AdapterLogger, BaseAdapterConfig, DatabaseCapabilities, DatabaseError, DatabaseErrorKind, DeleteOptions, InsertOptions, JoinSpec, OrderBySpec, PoolStats, SelectOptions, SqlParam, SqliteAdapterConfig, TransactionContext, TransactionOptions, UpdateOptions, UpsertOptions, WhereClause, WhereCondition, WhereOperator } from "@nextlyhq/adapter-drizzle/types";
+import { AdapterLogger, BaseAdapterConfig, DatabaseCapabilities, DatabaseError, DatabaseErrorKind, DeleteOptions, InsertOptions, JoinSpec, OrderBySpec, PoolStats, SelectOptions, SessionOptions, SqlParam, SqliteAdapterConfig, StatementSession, TransactionContext, TransactionOptions, UpdateOptions, UpsertOptions, WhereClause, WhereCondition, WhereOperator } from "@nextlyhq/adapter-drizzle/types";
 import { BetterSQLite3Database } from "drizzle-orm/better-sqlite3";
 import { AnyRelations } from "drizzle-orm";
 /**
@@ -18,7 +18,8 @@ export declare const VERSION = "0.1.0";
  * - No connection pooling (single file/connection)
  * - RETURNING clause supported (SQLite 3.35+)
  * - Savepoints supported via nested transactions
- * - No native ILIKE (uses LOWER() LIKE workaround)
+ * - No native ILIKE (both sides case-folded, then LIKE; the fold is Nextly's own
+ *   `nextly_fold_case`, registered on connect, since SQLite's `lower()` folds ASCII only)
  * - JSON support (not JSONB)
  * - No array types
  *
@@ -73,18 +74,6 @@ export declare class SqliteAdapter extends DrizzleAdapter {
    * surface area without changing the achievable concurrency.
    */
   private transactionQueue;
-  /**
-   * The transaction the current async chain is running inside, if any.
-   *
-   * A `transaction()` call made from INSIDE a transaction's work — a store
-   * writing on behalf of the caller, a plugin's write inside its own
-   * `ctx.db.transaction` — used to queue behind the very transaction that
-   * was waiting for it, and neither ever settled: that hung every later
-   * transaction on the instance too. Such a call now runs as a SAVEPOINT of
-   * the active transaction instead, so it commits or rolls back with it and
-   * its own failure undoes only its own part.
-   */
-  private readonly transactionScope;
   /**
    * Creates a new SQLite adapter instance.
    *
@@ -131,6 +120,8 @@ export declare class SqliteAdapter extends DrizzleAdapter {
    * @throws {DatabaseError} If query execution fails
    */
   executeQuery<T = unknown>(sql: string, params?: SqlParam[]): Promise<T[]>;
+  /** How long a transaction waits for the connection: `pool.connectionTimeoutMs`. */
+  private transactionWaitMs;
   /**
    * Execute work within a transaction.
    *
@@ -154,93 +145,36 @@ export declare class SqliteAdapter extends DrizzleAdapter {
    * Note: SQLite uses DEFERRED, IMMEDIATE, or EXCLUSIVE transaction modes
    * rather than isolation levels. This adapter uses IMMEDIATE.
    */
-  /** How long a transaction waits for the connection: `pool.connectionTimeoutMs`. */
-  private transactionWaitMs;
-  transaction<T>(work: (tx: TransactionContext) => Promise<T>, _options?: TransactionOptions): Promise<T>;
+  transaction<T>(work: (tx: TransactionContext) => Promise<T>, options?: TransactionOptions): Promise<T>;
   /**
-   * Hold `effect` until the transaction enclosing this async context commits,
-   * or run it now when none does.
-   *
-   * The effect belongs to the scope this async context runs in, even one
-   * that has already released or rolled back: a service whose own
-   * transaction nested as a savepoint registers from its caller's scope once
-   * that savepoint has released, and the change is undoable for as long as
-   * any scope around it is. The outermost transaction runs the effect once
-   * its COMMIT succeeds, unless a scope between the effect's scope and the
-   * outermost transaction rolled back, and drops every effect on ROLLBACK or
-   * a failed COMMIT. A context whose outermost transaction has already
-   * finished is outside any transaction, so its effect runs now, unless what
-   * it announces was undone and it has run no transaction since.
-   */
-  override afterCommit(effect: () => unknown, onDeferredFailure?: (error: unknown) => void): Promise<void>;
-  /**
-   * `effect`, bound to the async context it is registered from.
-   *
-   * A held effect runs after the outermost COMMIT, from the code that ran the
-   * outermost transaction, so without this it sees that code's context rather
-   * than its own: whatever its caller pinned around the write is gone. That
-   * includes who is calling. A scope pinned for a scoped API key lost there
-   * leaves a hook's nested call judged by the key's owner instead of the key,
-   * and a person's frame lost there leaves the hook told of nobody.
+   * Runs `work` outside a transaction, each statement committing as it runs,
+   * once no other flow's transaction is open on the one connection.
    *
-   * The adapter's own transaction scope is the one store it leaves: the
-   * effect runs once that transaction has finished, outside it, as an effect
-   * held to the outermost commit always has.
-   */
-  private inRegisteringContext;
-  /**
-   * Run the effects a committed transaction held, in order. A failure is
-   * reported, never thrown: the change is durable, and reporting the
-   * transaction as failed would invite a retry of something already done.
-   */
-  private runHeldEffects;
-  /** Hand a held effect's failure to its reporter, or to the adapter's log. */
-  private reportHeldEffectFailure;
-  /**
-   * Whether a `transaction()` call made here would join an open transaction
-   * as a savepoint. On SQLite it would: the connection is the only one, so a
-   * transaction open on it encloses whatever the async chain that opened it
-   * starts.
-   */
-  override inTransaction(): boolean;
-  /**
-   * Whether the calling async flow is inside a transaction that has not
-   * finished, judged from the transaction this flow was started inside,
-   * never from the connection: another request's open transaction answers
-   * false here, where its own `transaction()` queues behind that one.
-   *
-   * A flow started inside a transaction, even inside a savepoint that has
-   * since released, stays inside it until its outermost transaction has
-   * committed or rolled back: until then whatever it writes on the one
-   * connection lands in that transaction.
+   * @remarks
+   * Waits its turn in `transactionQueue` as a transaction does: a statement
+   * run while another flow's transaction is open would join it, and be undone
+   * if it rolled back. Transactions begun meanwhile wait behind the session in
+   * turn, so `work` must not open one of its own: it would wait behind the
+   * session that waits for it, until it fails as busy.
    */
-  override transactionOpenInFlow(): boolean;
+  override withSession<T>(work: (session: StatementSession) => Promise<T>, _options?: SessionOptions): Promise<T>;
   /**
-   * The scope a `transaction()` call made here nests in, or none when it
-   * opens a transaction of its own.
-   *
-   * A call made later from inside a savepoint that has since released runs
-   * inside the innermost scope open on the connection. Queued on an enclosing
-   * scope, or on the instance, it would wait behind the scope running there,
-   * which may be the one awaiting it. Savepoints on one connection form a
-   * stack, so whatever opens now is inside that innermost scope anyway; when
-   * none is open the call queues on the instance.
-   *
-   * The innermost open scope need not be related to the call. When it is a
-   * sibling savepoint that later rolls back, the call's write rolls back with
-   * it, although the call itself already resolved. Waiting for an unrelated
-   * scope instead could wait on the very scope that awaits the call.
+   * Runs `run` once every turn queued before it in `transactionQueue` is
+   * done, and holds the queue until `run` is done too.
    */
-  private nestingScope;
+  private takeTurn;
+  /** A held effect's failure that no reporter took goes to the adapter's logger. */
+  protected override logHeldEffectFailure(failure: Error): void;
   /**
-   * Run `work` as a savepoint of the active transaction: released when it
-   * resolves, rolled back to when it throws.
+   * The statements of a savepoint `depth` deep on the one connection:
+   * released when its work resolves, rolled back to when it throws.
    */
-  private runSavepoint;
+  private savepointSteps;
   /**
-   * Inner transaction body. Kept private so callers always go through
-   * the serialized `transaction()` queue above and the BEGIN/COMMIT
-   * pair is never invoked outside of it.
+   * One attempt's transaction body, settled rather than rejected for the
+   * transaction's own failure (`runOutermost`). Kept private so callers always
+   * go through the serialized `transaction()` queue above and the
+   * BEGIN/COMMIT pair is never invoked outside of it.
    */
   private runTransaction;
   /**

package/dist/index.mjs

@@ -1,9 +1,25 @@
-import { AsyncLocalStorage, AsyncResource } from "node:async_hooks";
 import { DrizzleAdapter } from "@nextlyhq/adapter-drizzle";
 import { createDatabaseError, isApplicationError, isDatabaseError, poolWaitTimeoutError } from "@nextlyhq/adapter-drizzle/types";
 import { checkDialectVersion } from "@nextlyhq/adapter-drizzle/version-check";
 import { drizzle } from "drizzle-orm/better-sqlite3";
 import { getTableConfig } from "drizzle-orm/sqlite-core";
+import { registerSqliteFoldCase } from "@nextlyhq/adapter-drizzle/text-match";
+// src/sql-functions.ts
+/**
+* The SQL functions a SQLite connection needs before Nextly's statements run on it.
+*
+* @module sql-functions
+*/
+/**
+* Register the SQL functions Nextly's statements call on SQLite, on `db`: the Unicode case fold
+* (`nextly_fold_case`), since SQLite's own `lower()` folds ASCII letters only.
+*
+* Every connection the adapter opens is handed here as it opens, before anything runs on it, so
+* no statement can reach a connection without the function.
+*/
+function registerSqliteFunctions(db) {
+	registerSqliteFoldCase(db);
+}
 // src/index.ts
 /**
 * @nextlyhq/adapter-sqlite
@@ -105,7 +121,8 @@ function sanitizeSqliteValue(v) {
 * - No connection pooling (single file/connection)
 * - RETURNING clause supported (SQLite 3.35+)
 * - Savepoints supported via nested transactions
-* - No native ILIKE (uses LOWER() LIKE workaround)
+* - No native ILIKE (both sides case-folded, then LIKE; the fold is Nextly's own
+*   `nextly_fold_case`, registered on connect, since SQLite's `lower()` folds ASCII only)
 * - JSON support (not JSONB)
 * - No array types
 *
@@ -161,18 +178,6 @@ var SqliteAdapter = class extends DrizzleAdapter {
 	*/
 	transactionQueue = Promise.resolve();
 	/**
-	* The transaction the current async chain is running inside, if any.
-	*
-	* A `transaction()` call made from INSIDE a transaction's work — a store
-	* writing on behalf of the caller, a plugin's write inside its own
-	* `ctx.db.transaction` — used to queue behind the very transaction that
-	* was waiting for it, and neither ever settled: that hung every later
-	* transaction on the instance too. Such a call now runs as a SAVEPOINT of
-	* the active transaction instead, so it commits or rolls back with it and
-	* its own failure undoes only its own part.
-	*/
-	transactionScope = new AsyncLocalStorage();
-	/**
 	* Creates a new SQLite adapter instance.
 	*
 	* @param config - Adapter configuration
@@ -209,6 +214,7 @@ var SqliteAdapter = class extends DrizzleAdapter {
 				readonly: this.config.readonly ?? false,
 				timeout: this.config.busyTimeout ?? DEFAULT_CONFIG.busyTimeout
 			});
+			registerSqliteFunctions(this.db);
 			if ((this.config.wal ?? DEFAULT_CONFIG.wal) && dbPath !== ":memory:" && !this.config.readonly) this.db.pragma("journal_mode = WAL");
 			if (this.config.foreignKeys ?? DEFAULT_CONFIG.foreignKeys) this.db.pragma("foreign_keys = ON");
 			await checkDialectVersion(this.db, "sqlite");
@@ -299,6 +305,10 @@ var SqliteAdapter = class extends DrizzleAdapter {
 			throw this.classifyError(error, sql);
 		}
 	}
+	/** How long a transaction waits for the connection: `pool.connectionTimeoutMs`. */
+	transactionWaitMs() {
+		return this.config.pool?.connectionTimeoutMs ?? DEFAULT_CONFIG.connectionTimeoutMs;
+	}
 	/**
 	* Execute work within a transaction.
 	*
@@ -322,206 +332,94 @@ var SqliteAdapter = class extends DrizzleAdapter {
 	* Note: SQLite uses DEFERRED, IMMEDIATE, or EXCLUSIVE transaction modes
 	* rather than isolation levels. This adapter uses IMMEDIATE.
 	*/
-	/** How long a transaction waits for the connection: `pool.connectionTimeoutMs`. */
-	transactionWaitMs() {
-		return this.config.pool?.connectionTimeoutMs ?? DEFAULT_CONFIG.connectionTimeoutMs;
-	}
-	async transaction(work, _options) {
-		const own = this.transactionScope.getStore();
-		const parent = this.nestingScope();
-		if (own && parent !== own) own.writesAfterClosing += 1;
-		if (parent) return enqueueIn(parent, () => this.runSavepoint(work, parent));
-		const run = async () => this.runTransaction(work);
-		const previous = this.transactionQueue;
-		const next = waitForTurn(previous, this.transactionWaitMs()).then(run);
-		this.transactionQueue = previous.then(() => next).catch(() => void 0);
-		const { result, effects } = await next;
-		await this.runHeldEffects(effects);
-		return result;
-	}
-	/**
-	* Hold `effect` until the transaction enclosing this async context commits,
-	* or run it now when none does.
-	*
-	* The effect belongs to the scope this async context runs in, even one
-	* that has already released or rolled back: a service whose own
-	* transaction nested as a savepoint registers from its caller's scope once
-	* that savepoint has released, and the change is undoable for as long as
-	* any scope around it is. The outermost transaction runs the effect once
-	* its COMMIT succeeds, unless a scope between the effect's scope and the
-	* outermost transaction rolled back, and drops every effect on ROLLBACK or
-	* a failed COMMIT. A context whose outermost transaction has already
-	* finished is outside any transaction, so its effect runs now, unless what
-	* it announces was undone and it has run no transaction since.
-	*/
-	async afterCommit(effect, onDeferredFailure) {
-		const scope = this.transactionScope.getStore();
-		if (!scope) {
-			await effect();
-			return;
-		}
-		const root = outermost(scope);
-		if (!root.finished) {
-			root.held.push({
-				effect: this.inRegisteringContext(effect),
-				onDeferredFailure,
-				scope,
-				writesBefore: scope.writesAfterClosing
-			});
-			return;
-		}
-		if (!undone(scope, scope.writesAfterClosing)) await effect();
+	transaction(work, options) {
+		return this.openOrJoin(work, options, {
+			run: () => this.takeTurn(() => this.runTransaction(work, options)),
+			retryable: () => false,
+			describe: () => ({
+				label: "a retryable error",
+				detail: {}
+			}),
+			logger: this.config.logger
+		});
 	}
 	/**
-	* `effect`, bound to the async context it is registered from.
-	*
-	* A held effect runs after the outermost COMMIT, from the code that ran the
-	* outermost transaction, so without this it sees that code's context rather
-	* than its own: whatever its caller pinned around the write is gone. That
-	* includes who is calling. A scope pinned for a scoped API key lost there
-	* leaves a hook's nested call judged by the key's owner instead of the key,
-	* and a person's frame lost there leaves the hook told of nobody.
+	* Runs `work` outside a transaction, each statement committing as it runs,
+	* once no other flow's transaction is open on the one connection.
 	*
-	* The adapter's own transaction scope is the one store it leaves: the
-	* effect runs once that transaction has finished, outside it, as an effect
-	* held to the outermost commit always has.
+	* @remarks
+	* Waits its turn in `transactionQueue` as a transaction does: a statement
+	* run while another flow's transaction is open would join it, and be undone
+	* if it rolled back. Transactions begun meanwhile wait behind the session in
+	* turn, so `work` must not open one of its own: it would wait behind the
+	* session that waits for it, until it fails as busy.
 	*/
-	inRegisteringContext(effect) {
-		return AsyncResource.bind(() => this.transactionScope.exit(effect));
+	async withSession(work, _options) {
+		this.refuseSessionInTransaction();
+		return this.takeTurn(() => work({ execute: (statement, params) => this.executeQuery(statement, params) }));
 	}
 	/**
-	* Run the effects a committed transaction held, in order. A failure is
-	* reported, never thrown: the change is durable, and reporting the
-	* transaction as failed would invite a retry of something already done.
+	* Runs `run` once every turn queued before it in `transactionQueue` is
+	* done, and holds the queue until `run` is done too.
 	*/
-	async runHeldEffects(effects) {
-		for (const { effect, onDeferredFailure } of effects) try {
-			await effect();
-		} catch (error) {
-			this.reportHeldEffectFailure(error, onDeferredFailure);
-		}
+	takeTurn(run) {
+		const previous = this.transactionQueue;
+		const next = waitForTurn(previous, this.transactionWaitMs()).then(run);
+		this.transactionQueue = previous.then(() => next).catch(() => void 0);
+		return next;
 	}
-	/** Hand a held effect's failure to its reporter, or to the adapter's log. */
-	reportHeldEffectFailure(error, onDeferredFailure) {
-		try {
-			if (onDeferredFailure) {
-				onDeferredFailure(error);
-				return;
-			}
-		} catch {}
-		const failure = error instanceof Error ? error : new Error(String(error));
+	/** A held effect's failure that no reporter took goes to the adapter's logger. */
+	logHeldEffectFailure(failure) {
 		if (this.config.logger?.error) this.config.logger.error(failure, { phase: "after-commit" });
-		else console.error("An effect held until commit failed:", failure);
-	}
-	/**
-	* Whether a `transaction()` call made here would join an open transaction
-	* as a savepoint. On SQLite it would: the connection is the only one, so a
-	* transaction open on it encloses whatever the async chain that opened it
-	* starts.
-	*/
-	inTransaction() {
-		return this.nestingScope() !== void 0;
-	}
-	/**
-	* Whether the calling async flow is inside a transaction that has not
-	* finished, judged from the transaction this flow was started inside,
-	* never from the connection: another request's open transaction answers
-	* false here, where its own `transaction()` queues behind that one.
-	*
-	* A flow started inside a transaction, even inside a savepoint that has
-	* since released, stays inside it until its outermost transaction has
-	* committed or rolled back: until then whatever it writes on the one
-	* connection lands in that transaction.
-	*/
-	transactionOpenInFlow() {
-		const own = this.transactionScope.getStore();
-		return own !== void 0 && !outermost(own).finished;
-	}
-	/**
-	* The scope a `transaction()` call made here nests in, or none when it
-	* opens a transaction of its own.
-	*
-	* A call made later from inside a savepoint that has since released runs
-	* inside the innermost scope open on the connection. Queued on an enclosing
-	* scope, or on the instance, it would wait behind the scope running there,
-	* which may be the one awaiting it. Savepoints on one connection form a
-	* stack, so whatever opens now is inside that innermost scope anyway; when
-	* none is open the call queues on the instance.
-	*
-	* The innermost open scope need not be related to the call. When it is a
-	* sibling savepoint that later rolls back, the call's write rolls back with
-	* it, although the call itself already resolved. Waiting for an unrelated
-	* scope instead could wait on the very scope that awaits the call.
-	*/
-	nestingScope() {
-		const own = this.transactionScope.getStore();
-		return own?.active ? own : own?.open.at(-1);
+		else super.logHeldEffectFailure(failure);
 	}
 	/**
-	* Run `work` as a savepoint of the active transaction: released when it
-	* resolves, rolled back to when it throws.
+	* The statements of a savepoint `depth` deep on the one connection:
+	* released when its work resolves, rolled back to when it throws.
 	*/
-	async runSavepoint(work, parent) {
+	savepointSteps(depth) {
 		const db = this.ensureDb();
-		const name = `nextly_sp_${parent.depth + 1}`;
-		try {
-			const ctx = this.createTransactionContext(db);
-			db.exec(`SAVEPOINT ${name}`);
-			const scope = openScope(parent);
-			try {
-				const result = await this.transactionScope.run(scope, () => work(ctx));
-				await settleNested(scope);
+		const name = `nextly_sp_${depth}`;
+		return {
+			context: this.createTransactionContext(db),
+			begin: () => {
+				db.exec(`SAVEPOINT ${name}`);
+			},
+			commit: () => {
+				db.exec(`RELEASE ${name}`);
+			},
+			rollback: () => {
+				db.exec(`ROLLBACK TO ${name}`);
 				db.exec(`RELEASE ${name}`);
-				return result;
-			} catch (error) {
-				await settleNested(scope);
-				scope.rolledBack = true;
-				try {
-					db.exec(`ROLLBACK TO ${name}`);
-					db.exec(`RELEASE ${name}`);
-				} catch {}
-				throw error;
 			}
-		} catch (error) {
-			if (isApplicationError(error)) throw error;
-			throw this.classifyError(error);
-		}
+		};
 	}
 	/**
-	* Inner transaction body. Kept private so callers always go through
-	* the serialized `transaction()` queue above and the BEGIN/COMMIT
-	* pair is never invoked outside of it.
+	* One attempt's transaction body, settled rather than rejected for the
+	* transaction's own failure (`runOutermost`). Kept private so callers always
+	* go through the serialized `transaction()` queue above and the
+	* BEGIN/COMMIT pair is never invoked outside of it.
 	*/
-	async runTransaction(work) {
+	async runTransaction(work, options) {
 		const db = this.ensureDb();
-		const startTime = Date.now();
 		try {
-			const ctx = this.createTransactionContext(db);
-			db.exec("BEGIN IMMEDIATE");
-			const scope = openScope();
-			try {
-				const result = await this.transactionScope.run(scope, () => work(ctx));
-				await settleNested(scope);
-				db.exec("COMMIT");
-				scope.finished = true;
-				if (this.config.logger?.debug) {
-					const durationMs = Date.now() - startTime;
-					this.config.logger.debug("Transaction committed", { durationMs });
+			return await this.settleOutermost({
+				context: this.createTransactionContext(db),
+				join: { adapter: (depth) => this.savepointSteps(depth) },
+				begin: () => {
+					db.exec("BEGIN IMMEDIATE");
+				},
+				commit: () => {
+					db.exec("COMMIT");
+				},
+				rollback: () => {
+					try {
+						db.exec("ROLLBACK");
+					} catch (error) {
+						if (db.inTransaction) throw error;
+					}
 				}
-				return {
-					result,
-					effects: scope.held.filter((held) => !undone(held.scope, held.writesBefore))
-				};
-			} catch (error) {
-				await settleNested(scope);
-				scope.rolledBack = true;
-				scope.finished = true;
-				scope.held.length = 0;
-				try {
-					db.exec("ROLLBACK");
-				} catch {}
-				throw error;
-			}
+			}, work, options);
 		} catch (error) {
 			if (isApplicationError(error)) throw error;
 			throw this.classifyError(error);
@@ -565,6 +463,7 @@ var SqliteAdapter = class extends DrizzleAdapter {
 		if (data.length === 0) return [];
 		const db = this.ensureDb();
 		if (data.length === 1) return [await this.insert(table, data[0], options)];
+		const tableObj = this.resolvedTableObject(table);
 		const columns = Object.keys(data[0]);
 		const params = [];
 		const valuesClauses = [];
@@ -583,9 +482,7 @@ var SqliteAdapter = class extends DrizzleAdapter {
 			sql += ` RETURNING ${returning}`;
 		} else sql += " RETURNING *";
 		try {
-			const rows = db.prepare(sql).all(...params);
-			const tableObj = this.getTableObject(table);
-			return rows.map((r) => this.mapRowFromRawSql(tableObj, r));
+			return db.prepare(sql).all(...params).map((r) => this.mapRowFromRawSql(tableObj, r));
 		} catch (error) {
 			throw this.handleQueryError(error, "insertMany", table);
 		}
@@ -672,7 +569,8 @@ var SqliteAdapter = class extends DrizzleAdapter {
 				}
 			},
 			insert: async (table, data, options) => {
-				const mapped = this.mapKeysToSqlColumns(this.getTableObject(table), data);
+				const tableObj = this.resolvedTableObject(table);
+				const mapped = this.mapKeysToSqlColumns(tableObj, data);
 				const columns = Object.keys(mapped);
 				const values = Object.values(mapped).map(sanitizeSqliteValue);
 				const placeholders = values.map(() => "?").join(", ");
@@ -680,7 +578,7 @@ var SqliteAdapter = class extends DrizzleAdapter {
 				const ret = options?.returning;
 				const returningEmpty = Array.isArray(ret) && ret.length === 0;
 				if (!returningEmpty) {
-					const returning = !ret || ret === "*" ? "*" : this.mapColumnNamesToSql(this.getTableObject(table), ret).map((col) => this.escapeIdentifier(col)).join(", ");
+					const returning = !ret || ret === "*" ? "*" : this.mapColumnNamesToSql(tableObj, ret).map((col) => this.escapeIdentifier(col)).join(", ");
 					sql += ` RETURNING ${returning}`;
 				}
 				const stmt = db.prepare(sql);
@@ -689,11 +587,11 @@ var SqliteAdapter = class extends DrizzleAdapter {
 					return;
 				}
 				const rows = stmt.all(...values);
-				return this.mapRowFromRawSql(this.getTableObject(table), rows[0]);
+				return this.mapRowFromRawSql(tableObj, rows[0]);
 			},
 			insertMany: async (table, data, options) => {
 				if (data.length === 0) return [];
-				const tableObj = this.getTableObject(table);
+				const tableObj = this.resolvedTableObject(table);
 				const mappedRecords = data.map((r) => this.mapKeysToSqlColumns(tableObj, r));
 				const columns = Object.keys(mappedRecords[0]);
 				const allValues = [];
@@ -710,7 +608,7 @@ var SqliteAdapter = class extends DrizzleAdapter {
 				const ret = options?.returning;
 				const returningEmpty = Array.isArray(ret) && ret.length === 0;
 				if (!returningEmpty) {
-					const returning = !ret || ret === "*" ? "*" : this.mapColumnNamesToSql(this.getTableObject(table), ret).map((col) => this.escapeIdentifier(col)).join(", ");
+					const returning = !ret || ret === "*" ? "*" : this.mapColumnNamesToSql(tableObj, ret).map((col) => this.escapeIdentifier(col)).join(", ");
 					sql += ` RETURNING ${returning}`;
 				}
 				const stmt = db.prepare(sql);
@@ -817,44 +715,6 @@ function isSqliteAdapter(value) {
 	return value instanceof SqliteAdapter;
 }
 /**
-* Open the scope of a savepoint inside `parent`, or of an outermost
-* transaction when there is none, and record it among the connection's open
-* scopes.
-*/
-function openScope(parent) {
-	const scope = {
-		active: true,
-		depth: parent ? parent.depth + 1 : 0,
-		parent,
-		rolledBack: false,
-		writesAfterClosing: 0,
-		finished: false,
-		held: [],
-		queue: Promise.resolve(),
-		open: parent ? parent.open : []
-	};
-	scope.open.push(scope);
-	return scope;
-}
-/** The outermost transaction `scope` runs inside; itself for that one. */
-function outermost(scope) {
-	let at = scope;
-	while (at.parent) at = at.parent;
-	return at;
-}
-/**
-* Whether an effect registered from `scope` describes a write that was
-* undone: `scope`, or a scope it runs inside, rolled back, and no
-* transaction had run from its context since it closed when the effect was
-* registered (`writesBefore`). An effect registered before such a write
-* still describes the undone one.
-*/
-function undone(scope, writesBefore) {
-	if (writesBefore > 0) return false;
-	for (let at = scope; at; at = at.parent) if (at.rolledBack) return true;
-	return false;
-}
-/**
 * Settles once `turn` does, or rejects with the pool-wait timeout error once
 * `boundMs` passes first. A bound of 0 waits without limit, as pg-pool reads a
 * `connectionTimeoutMillis` of 0.
@@ -870,23 +730,6 @@ function waitForTurn(turn, boundMs) {
 		});
 	});
 }
-/** Chain `run` onto a scope's queue, keeping the queue itself unrejected. */
-function enqueueIn(scope, run) {
-	const next = scope.queue.then(run, run);
-	scope.queue = next.catch(() => void 0);
-	return next;
-}
-/**
-* Close a scope to new nested calls and wait for those already queued. A call
-* arriving after this joins the innermost scope still open on the connection,
-* or, when none is, goes to the instance queue behind the transaction.
-*/
-async function settleNested(scope) {
-	scope.active = false;
-	const index = scope.open.indexOf(scope);
-	if (index !== -1) scope.open.splice(index, 1);
-	await scope.queue;
-}
 export { SqliteAdapter, VERSION, createSqliteAdapter, isSqliteAdapter };
 
 //# sourceMappingURL=index.mjs.map