imodel 0.20.0 → 0.20.1

package/index.mjs

@@ -1,5 +1,5 @@
 /*!
- * imodel v0.20.0
+ * imodel v0.20.1
  * (c) 2019-2026 猛火Fierflame
  * @license MIT
  */
@@ -429,6 +429,26 @@ function createInterface (connPromise, baseTransaction) {
     }
   }
   const ci = {
+    async dbType() {
+      const conn = await connPromise;
+      return conn.dbType;
+    },
+    async dbVersion() {
+      const conn = await connPromise;
+      return conn.dbVersion(env);
+    },
+    async query(...values) {
+      const conn = await connPromise;
+      return conn.query(env, ...values);
+    },
+    async exec(...values) {
+      const conn = await connPromise;
+      return conn.exec(env, ...values);
+    },
+    async type(table) {
+      const conn = await connPromise;
+      return conn.type(env, table);
+    },
     async insert(table, data, keys, conflictTarget, conflictSet, conflictWhere) {
       const conn = await connPromise;
       return conn.insert(env, table.table, table.columns, data, keys, conflictTarget, conflictSet, conflictWhere);
@@ -2486,7 +2506,7 @@ function sort2column(sort, fieldColumns) {
   return sort.map(([f, d]) => [fieldColumns[f], d]);
 }
 
-/** @import Connection from './index.mjs' */
+/** @import Connection from './index.mts' */
 /** @import { FieldDefine, Fields, Skip, TableDefine, FieldType, SelectItem, LockType, ConnectionInterface } from '../types' */
 
 /**
@@ -2687,7 +2707,7 @@ function find (sql, skip) {
   };
 }
 
-/** @import Connection from './index.mjs' */
+/** @import Connection from './index.mts' */
 /** @import { Environment, TableDefine, Skip, SelectItem, ConnectionInterface, BaseEnvironment } from '../types' */
 
 /**
@@ -3578,50 +3598,22 @@ var index$1 = /*#__PURE__*/Object.freeze({
 	upsert: upsert
 });
 
-/** @import { Wheres } from '../Where.mjs' */
-/** @import { SetValue } from '../set.mjs' */
-/** @import { Environment, TableValue } from '../types' */
-/** @import { Fields, FieldValue, IndexOptions, MainFieldType, TableDefine } from '../types/table' */
-/** @import { Queryable } from '../types/options' */
-/** @import { Column, ColumnOptions } from '../types/column' */
-/** @import { Action, ConnectionInterface, DBTable, IConnection, Savepoint, Skip, TableType, TransactionHandler } from '../types/connection' */
-
+/* eslint-disable max-lines */
 
-/**
- * @template {{}} [E={}]
- */
 class Connection {
-  /** @type {Environment<E>} */
   #env;
-  /** @type {() => Promise<IConnection<E>>} */
   #getConnection;
-  /** @type {E?} */
   #baseTransaction;
-  /**
-   *
-   * @param {PromiseLike<IConnection<E>> | IConnection<E>} connection
-   * @param {E?} [transaction]
-   */
   constructor(connection, transaction = null) {
     this.#baseTransaction = transaction;
     const getConnection = async () => connection;
     this.#getConnection = getConnection;
     [this.#interface, this.#env] = createInterface(connection, transaction);
   }
-  /** @type {ConnectionInterface} */
   #interface;
-  /**
-   *
-   * @returns {Connection<E>}
-   */
   clone() {
     return new Connection(this.#getConnection(), this.#baseTransaction);
   }
-  /**
-   * @template T
-   * @param {Action<T>} action
-   * @returns {Promise<T>}
-   */
   async call(action) {
     const env = {
       isDevelopment,
@@ -3638,66 +3630,21 @@ class Connection {
     let conn = null;
     return action.invoke(() => conn ||= connect(), this, env);
   }
-
-  /** @return {Promise<string>} */
   async dbType() {
-    const conn = await this.#getConnection();
-    return conn.dbType;
+    return this.#interface.dbType();
   }
-  /** @return {Promise<string>} */
   async dbVersion() {
-    const conn = await this.#getConnection();
-    return conn.dbVersion(this.#env);
+    return this.#interface.dbVersion();
   }
-  /**
-   *
-   * @param {...any} values
-   * @returns {Promise<any[]>}
-   */
   async query(...values) {
-    const conn = await this.#getConnection();
-    return conn.query(this.#env, ...values);
+    return this.#interface.query(...values);
   }
-  /**
-   *
-   * @param {...any} values
-   * @returns {Promise<number>}
-   */
   async exec(...values) {
-    const conn = await this.#getConnection();
-    return conn.exec(this.#env, ...values);
+    return this.#interface.exec(...values);
   }
-  /**
-   *
-   * @param {string} table
-   * @returns {Promise<TableType?>}
-   */
   async type(table) {
-    const conn = await this.#getConnection();
-    return conn.type(this.#env, table);
+    return this.#interface.type(table);
   }
-  /**
-   * @template T
-   * @overload
-   * @param {Build<T>} build
-   * @param {object} data
-   * @param {object | boolean} [saved]
-   * @returns {T}
-   */
-  /**
-   * @template {Fields} T
-   * @overload
-   * @param {TableDefine<T>} table
-   * @param {object} data
-   * @param {object | boolean} [saved]
-   * @returns {FieldValue<T>}
-   */
-  /**
-   * @param {Build | TableDefine} p
-   * @param {object} data
-   * @param {object | boolean} [saved]
-   * @returns {any}
-   */
   build(p, data, saved) {
     if (typeof p[Build] === 'function') {
       return p[Build](data, saved || false, this.#env);
@@ -3712,619 +3659,227 @@ class Connection {
       ...saved
     };
   }
-  /**
-   * @deprecated
-   * @template {TableDefine} T
-   * @overload
-   * @param {T} model
-   * @param {object[]} list
-   * @returns {Promise<TableValue<T>[]>}
-   */
-  /**
-   * @deprecated
-   * @template {TableDefine} T
-   * @overload
-   * @param {T} model
-   * @param {object} value
-   * @returns {Promise<T extends Build<infer R> ? R : TableValue<T>>}
-   */
-  /**
-   * @deprecated
-   * @template {TableDefine} T
-   * @overload
-   * @param {T} model
-   * @param {object | object[]} value
-   * @returns {Promise<TableValue<T>[] | (T extends Build<infer R> ? R : TableValue<T>)>}
-   */
-  /**
-   * @deprecated
-   * @template {TableDefine} T
-   * @param {T} model
-   * @param {object | object[]} p
-   * @param {Skip} [skip]
-   * @returns {Promise<TableValue<T>[] | (T extends Build<infer R> ? R : TableValue<T>)>}
-   */
+  /** @deprecated */
+
+  /** @deprecated */
+
+  /** @deprecated */
+
+  /** @deprecated */
   async create(model, p, skip) {
     return this.call(create(model, p, skip));
   }
-  /**
-   *
-   * @deprecated
-   * @template {TableDefine} T
-   * @param {T} sql
-   * @param {string[]} fields
-   * @param {Skip} [skip]
-   * @returns {Promise<T extends TableDefine<infer F> ? FieldValue<F>[] : never>}
-   */
+  /** @deprecated */
   async search(sql, fields, skip) {
     return this.call(search(sql, fields, skip));
   }
-  /**
-   * @deprecated
-   * @template {TableDefine} T
-   * @param {T} sql
-   * @param {Skip} [skip]
-   * @returns {Promise<T extends Build<infer R > ? R[] : T extends TableDefine<infer F> ? FieldValue<F>[] : never>}
-   */
+  /** @deprecated */
   async find(sql, skip) {
     return this.call(find(sql, skip));
   }
-  /**
-   *
-   * @deprecated
-   * @template {TableDefine} T
-   * @param {T} sql
-   * @param {Skip} [skip]
-   * @returns {Promise<T extends Build<infer R > ? R : T extends TableDefine<infer F> ? FieldValue<F> : never>}
-   */
+  /** @deprecated */
   async first(sql, skip) {
     return this.call(first(sql, skip));
   }
-  /**
-   * @deprecated
-   * @template T
-   * @param {TableDefine} model
-   * @param {T} data
-   * @param {Record<string, any>?} [newData]
-   * @param {Skip} [skip]
-   * @returns {Promise<(T extends Save ? T : object)?>}
-   */
+  /** @deprecated */
   async save(model, data, newData, skip) {
     return this.call(save(model, data, newData, skip));
   }
-  /**
-   *
-   * @deprecated
-   * @template T
-   * @param {TableDefine} tableDef
-   * @param {T} data
-   * @returns {Promise<(T extends Destroy ? T : object)?>}
-   */
+  /** @deprecated */
   async completelyDestroy(tableDef, data) {
     return this.call(completelyDestroy(tableDef, data));
   }
-  /**
-   *
-   * @deprecated
-   * @template {object} T
-   * @param {TableDefine} tableDef
-   * @param {T} data
-   * @param {Record<string, SetValue>} value
-   * @returns {Promise<(T extends PseudoDestroy ? T : object)?>}
-   */
+  /** @deprecated */
   async pseudoDestroy(tableDef, data, value) {
     return this.call(pseudoDestroy(tableDef, data, value));
   }
-  /**
-   * @deprecated
-   * @template {Destroy & PseudoDestroy} T
-   * @overload
-   * @param {TableDefine} table
-   * @param {T} data
-   * @param {Record<string, any> | boolean} [update]
-   * @returns {Promise<T?>}
-   */
-  /**
-   * @deprecated
-   * @template {Destroy & PseudoDestroy} T
-   * @overload
-   * @param {TableDefine} table
-   * @param {T} data
-   * @param {Record<string, any> | boolean} [update]
-   * @returns {Promise<T | object | null>}
-   */
-  /**
-   * @deprecated
-   * @overload
-   * @param {TableDefine} table
-   * @param {any} data
-   * @param {Record<string, any> | boolean} [update]
-   * @returns {Promise<object?>}
-   */
-  /**
-   * @deprecated
-   * @param {TableDefine} tableDef
-   * @param {any} data
-   * @param {Record<string, any> | boolean} [update]
-   * @returns {Promise<object?>}
-   */
+  /** @deprecated */
+
+  /** @deprecated */
+
+  /** @deprecated */
+
+  /** @deprecated */
   async destroy(tableDef, data, update) {
     return this.call(destroy(tableDef, data, update));
   }
-  /**
-   * @deprecated
-   * @param {Queryable} queryable
-   * @param {Record<string, SetValue> | boolean} [update]
-   * @returns {Promise<number>}
-   */
+  /** @deprecated */
   async destroyMany(queryable, update) {
     return this.call(destroyMany(queryable, update));
   }
-  /**
-   * @deprecated
-   * @template {object} T
-   * @overload
-   * @param {TableDefine} tableDefine
-   * @param {T} data
-   * @param {boolean} [ignoreConflict]
-   * @returns {Promise<T>}
-   */
-  /**
-   * @deprecated
-   * @template {object} T
-   * @overload
-   * @param {TableDefine} tableDefine
-   * @param {T[]} data
-   * @param {boolean} [ignoreConflict]
-   * @returns {Promise<T[]>}
-   */
-  /**
-   * @deprecated
-   * @template {object} T
-   * @overload
-   * @param {TableDefine} tableDefine
-   * @param {T} data
-   * @param {string[]} [keys]
-   * @param {boolean} [ignoreConflict]
-   * @returns {Promise<T>}
-   */
-  /**
-   * @deprecated
-   * @template {object} T
-   * @overload
-   * @param {TableDefine} tableDefine
-   * @param {T[]} data
-   * @param {string[]} [keys]
-   * @param {boolean} [ignoreConflict]
-   * @returns {Promise<T[]>}
-   */
-  /**
-   * @deprecated
-   * @template {object} T
-   * @overload
-   * @param {TableDefine} tableDefine
-   * @param {T} data
-   * @param {string[] | boolean} [keys]
-   * @param {boolean} [ignoreConflict]
-   * @returns {Promise<T>}
-   */
-  /**
-   * @deprecated
-   * @template {object} T
-   * @overload
-   * @param {TableDefine} tableDefine
-   * @param {T[]} data
-   * @param {string[] | boolean} [keys]
-   * @param {boolean} [ignoreConflict]
-   * @returns {Promise<T[]>}
-   */
-  /**
-   * @deprecated
-   * @template {object} T
-   * @overload
-   * @param {TableDefine} tableDefine
-   * @param {T | T[]} data
-   * @param {string[] | boolean} [keys]
-   * @param {boolean} [ignoreConflict]
-   * @returns {Promise<T | T[]>}
-   */
-  /**
-   * @deprecated
-   * @template {object} T
-   * @param {TableDefine} table
-   * @param {T | T[]} data
-   * @param {string[] | boolean} [keys]
-   * @param {boolean} [ignoreConflict]
-   * @returns {Promise<T | T[]>}
-   */
+  /** @deprecated */
+
+  /** @deprecated */
+
+  /** @deprecated */
+
+  /** @deprecated */
+
+  /** @deprecated */
+
+  /** @deprecated */
+
+  /** @deprecated */
+
+  /** @deprecated */
   async insert(table, data, keys, ignoreConflict) {
     // @ts-ignore
     return this.call(insert(table, data, keys, ignoreConflict));
   }
-  /**
-   * @deprecated
-   * @template {object} T
-   * @overload
-   * @param {TableDefine} tableDefine
-   * @param {T} data
-   * @param {Record<string, SetValue>} [conflictSet]
-   * @returns {Promise<T>}
-   */
-  /**
-   * @deprecated
-   * @template {object} T
-   * @overload
-   * @param {TableDefine} tableDefine
-   * @param {T[]} data
-   * @param {Record<string, SetValue>} [conflictSet]
-   * @returns {Promise<T[]>}
-   */
-  /**
-   * @deprecated
-   * @template {object} T
-   * @overload
-   * @param {TableDefine} tableDefine
-   * @param {T} data
-   * @param {null | string[]} [keys]
-   * @param {Record<string, SetValue>} [conflictSet]
-   * @returns {Promise<T>}
-   */
-  /**
-   * @deprecated
-   * @template {object} T
-   * @overload
-   * @param {TableDefine} tableDefine
-   * @param {T[]} data
-   * @param {null | string[]} [keys]
-   * @param {Record<string, SetValue>} [conflictSet]
-   * @returns {Promise<T[]>}
-   */
-  /**
-   * @deprecated
-   * @template {object} T
-   * @overload
-   * @param {TableDefine} tableDefine
-   * @param {T} data
-   * @param {null | string[]} [keys]
-   * @param {string[] | boolean} [conflictKeys]
-   * @param {Record<string, SetValue>} [conflictSet]
-   * @returns {Promise<T>}
-   */
-  /**
-   * @deprecated
-   * @template {object} T
-   * @overload
-   * @param {TableDefine} tableDefine
-   * @param {T[]} data
-   * @param {null | string[]} [keys]
-   * @param {string[] | boolean} [conflictKeys]
-   * @param {Record<string, SetValue>} [conflictSet]
-   * @returns {Promise<T[]>}
-   */
-  /**
-   * @deprecated
-   * @template {object} T
-   * @overload
-   * @param {TableDefine} tableDefine
-   * @param {T} data
-   * @param {null | string[] | boolean | Record<string, SetValue>} [keys]
-   * @param {string[] | boolean | Record<string, SetValue>} [conflictKeys]
-   * @param {Record<string, SetValue>} [conflictSet]
-   * @returns {Promise<T>}
-   */
-  /**
-   * @deprecated
-   * @template {object} T
-   * @overload
-   * @param {TableDefine} tableDefine
-   * @param {T[]} data
-   * @param {null | string[] | boolean | Record<string, SetValue>} [keys]
-   * @param {string[] | boolean | Record<string, SetValue>} [conflictKeys]
-   * @param {Record<string, SetValue>} [conflictSet]
-   * @returns {Promise<T[]>}
-   */
-  /**
-   * @deprecated
-   * @template {object} T
-   * @overload
-   * @param {TableDefine} tableDefine
-   * @param {T | T[]} data
-   * @param {null | string[] | boolean | Record<string, SetValue>} [keys]
-   * @param {string[] | boolean | Record<string, SetValue>} [conflictKeys]
-   * @param {Record<string, SetValue>} [conflictSet]
-   * @returns {Promise<T | T[]>}
-   */
-  /**
-   * @deprecated
-   * @template {object} T
-   * @param {TableDefine} tableDefine
-   * @param {T | T[]} data
-   * @param {null | string[] | boolean | Record<string, SetValue>} [keys]
-   * @param {string[] | boolean | Record<string, SetValue>} [conflictKeys]
-   * @param {Record<string, SetValue>} [conflictSet]
-   * @returns {Promise<T | T[]>}
-   */
+  /** @deprecated */
+
+  /** @deprecated */
+
+  /** @deprecated */
+
+  /** @deprecated */
+
+  /** @deprecated */
+
+  /** @deprecated */
+
+  /** @deprecated */
+
+  /** @deprecated */
+
+  /** @deprecated */
+
+  /** @deprecated */
   async upsert(tableDefine, data, keys, conflictKeys, conflictSet) {
     // @ts-ignore
     return this.call(
     // @ts-ignore
     upsert(tableDefine, data, keys, conflictKeys, conflictSet));
   }
-  /**
-   * @deprecated
-   * @param {TableDefine} table
-   * @param {Record<string, any>} update
-   * @param {Wheres?} [where]
-   * @param {boolean | Skip} [skip]
-   * @returns {Promise<number>}
-   */
+  /** @deprecated */
   async update(table, update$1, where, skip) {
     return this.call(update(table, update$1, where, skip));
   }
-  /**
-   * @deprecated
-   * @template {Fields<MainFieldType>} T
-   * @param {TableDefine<T>} table
-   * @param {Record<string, any>} update
-   * @param {string[]?} [returning]
-   * @param {Wheres?} [where]
-   * @param {boolean | Skip} [skip]
-   * @returns {Promise<any[]>}
-   */
+  /** @deprecated */
   async updateReturn(table, update, returning, where, skip) {
     return this.call(updateReturn(table, update, returning, where, skip));
   }
-  /**
-   * @deprecated
-   * @param {TableDefine} table
-   * @param {string[]} pKeys
-   * @param {string[]} setKeys
-   * @param {Record<string, any>[]} list
-   * @param {boolean | Skip} [skip]
-   * @returns {Promise<number>}
-   */
+  /** @deprecated */
   async updateMany(table, pKeys, setKeys, list, skip) {
     return this.call(updateList(table, pKeys, setKeys, list, skip));
   }
-  /**
-   * @deprecated
-   * @template {Fields<MainFieldType>} T
-   * @param {TableDefine<T>} table
-   * @param {string[]} pKeys
-   * @param {string[]} setKeys
-   * @param {Record<string, any>[]} list
-   * @param {string[]?} [returning]
-   * @param {boolean | Skip} [skip]
-   * @returns {Promise<any[]>}
-   */
+  /** @deprecated */
   async updateManyReturn(table, pKeys, setKeys, list, returning, skip) {
     return this.call(updateListReturn(table, pKeys, setKeys, list, returning, skip));
   }
-  /**
-   * @deprecated
-   * @param {TableDefine} table
-   * @param {Wheres?} [where]
-   * @returns {Promise<number>}
-   */
+  /** @deprecated */
   async delete(table, where) {
     return this.call(_delete(table, where));
   }
-
-  /**
-   * @deprecated
-   * @template {Fields<MainFieldType>} T
-   * @param {TableDefine<T>} table
-   * @param {string[]?} [returning]
-   * @param {Wheres?} [where]
-   * @returns {Promise<any[]>}
-   */
+  /** @deprecated */
   async deleteReturn(table, returning, where) {
     return this.call(deleteReturn(table, returning, where));
   }
-  /**
-   *
-   * @deprecated
-   * @param {Queryable} queryable
-   * @returns {Promise<number>}
-   */
+  /** @deprecated */
   async count(queryable) {
     return this.call(count(queryable));
   }
-  /**
-   * @deprecated
-   * @param {Queryable} queryable
-   * @returns {Promise<any[]>}
-   */
+  /** @deprecated */
   async select(queryable) {
     return this.call(select(queryable));
   }
-  /**
-   * @param {string} table
-   * @param {string} column
-   * @param {string} type
-   * @param {ColumnOptions<any>} options
-   * @returns {Promise<number>}
-   */
   async addColumn(table, column, type, options) {
     const conn = await this.#getConnection();
     return conn.addColumn(this.#env, table, column, type, setDefaultOptions(options));
   }
-  /**
-   * @param {string} table
-   * @param {string} column
-   * @param {string} type
-   * @param {ColumnOptions<any>} options
-   * @returns {Promise<number>}
-   */
   async changeColumn(table, column, type, options) {
     const conn = await this.#getConnection();
     return conn.changeColumn(this.#env, table, column, type, setDefaultOptions(options));
   }
-  /**
-   * @param {string} table
-   * @param {string} column
-   * @param {boolean} nullable
-   * @returns {Promise<number>}
-   */
   async changeColumnNull(table, column, nullable) {
     const conn = await this.#getConnection();
     return conn.changeColumnNull(this.#env, table, column, nullable);
   }
-  /**
-   * @param {string} table
-   * @param {string} column
-   * @returns {Promise<number>}
-   */
   async dropColumn(table, column) {
     const conn = await this.#getConnection();
     return conn.dropColumn(this.#env, table, column);
   }
-  /**
-   * @param {string} table
-   * @param {string} column
-   * @param {string} newName
-   * @returns {Promise<number>}
-   */
   async renameColumn(table, column, newName) {
     const conn = await this.#getConnection();
     return conn.renameColumn(this.#env, table, column, newName);
   }
-  /**
-   * @param {string} table
-   * @param {string} name
-   * @param {string[]} fields
-   * @param {IndexOptions} [options]
-   * @returns {Promise<number>}
-   */
   async addIndex(table, name, fields, options = {}) {
     const conn = await this.#getConnection();
     return conn.addIndex(this.#env, table, name, fields, options);
   }
-  /**
-   * @param {string} table
-   * @param {string} name
-   * @returns {Promise<number>}
-   */
   async dropIndex(table, name) {
     const conn = await this.#getConnection();
     return conn.dropIndex(this.#env, table, name);
   }
-  /**
-   * @param {string} table
-   * @param {Column<any>[]} fields
-   * @returns {Promise<number>}
-   */
   async createTable(table, fields) {
     const conn = await this.#getConnection();
     return conn.createTable(this.#env, table, fields.map(setDefaultOptions));
   }
-  /**
-   * @param {string} table
-   * @returns {Promise<number>}
-   */
   async dropTable(table) {
     const conn = await this.#getConnection();
     return conn.dropTable(this.#env, table);
   }
-  /**
-   * @param {string} table
-   * @param {string} newName
-   * @returns {Promise<number>}
-   */
   async renameTable(table, newName) {
     const conn = await this.#getConnection();
     return conn.renameTable(this.#env, table, newName);
   }
-  /**
-   * @template T
-   * @param {(signal: AbortSignal) => PromiseLike<T> | T} fn
-   * @returns {Promise<T>}
-   */
-  async #transaction(fn) {
-    return this.#interface.transaction(fn);
-  }
-  abort() {
-    return this.#interface.abort();
-  }
-  /**
-   * @returns {Promise<Savepoint>}
-   */
-  async savepoint() {
-    return this.#interface.savepoint();
-  }
-  [Symbol.dispose]() {
-    this.#interface.abort();
-  }
-  /**
-   * @param {string} table
-   * @returns {Promise<DBTable?>}
-   */
   async loadTable(table) {
     const conn = await this.#getConnection();
     return conn.loadTables(this.#env, [table]).then(v => v[0] || null);
   }
-  /**
-   * @param {string[]} tables
-   * @returns {Promise<DBTable[]>}
-   */
   async loadTables(tables) {
     const conn = await this.#getConnection();
     return conn.loadTables(this.#env, tables);
   }
-  /**
-   * @param {TableDefine | DBTable} table
-   * @returns {Promise<void>}
-   */
   async syncTable(table) {
     const conn = await this.#getConnection();
     return conn.syncTables(this.#env, table2db([table]));
   }
-  /**
-   * @param {(TableDefine | DBTable)[]} tables
-   * @returns {Promise<void>}
-   */
   async syncTables(tables) {
     const conn = await this.#getConnection();
     return conn.syncTables(this.#env, table2db(tables));
   }
+  async #transaction(fn) {
+    return this.#interface.transaction(fn);
+  }
+  abort() {
+    return this.#interface.abort();
+  }
+  async savepoint() {
+    return this.#interface.savepoint();
+  }
+  [Symbol.dispose]() {
+    this.#interface.abort();
+  }
   /**
    * @template T
    * @overload
-   * @param {(t: Connection) => PromiseLike<T> | T} fn
+   * @param {Action<T> |((t: Connection, signal: AbortSignal) => PromiseLike<T> | T)} fn
    * @returns {Promise<T>}
    */
-  /**
-   * @overload
-   * @returns {TransactionHandler}
-   */
-  /**
-   *
-   * @template T
-   * @param {(t: Connection, signal: AbortSignal) => PromiseLike<T> | T} [fn]
-   * @returns {Promise<T> | TransactionHandler}
-   */
-  /**
-   *
-   * @template T
-   * @param {(t: Connection, signal: AbortSignal) => PromiseLike<T> | T} [fn]
-   * @returns {Promise<T> | TransactionHandler}
-   */
+
   transaction(fn) {
+    if (Array.isArray(fn)) {
+      return this.#transaction(signal => Promise.all(fn.map(v => {
+        if (typeof v === 'function') {
+          return v(this, signal);
+        }
+        return this.call(v);
+      })));
+    }
     if (typeof fn === 'function') {
       return this.#transaction(signal => fn(this, signal));
     }
-    /** @type {(p: AbortSignal) => void} */
+    if (fn && typeof fn === 'object') {
+      return this.#transaction(() => this.call(fn));
+    }
     let throwAborted = () => {};
-    /** @type {Promise<void>} */
     const abortedPromise = new Promise((_, r) => {
       throwAborted = r;
     });
     abortedPromise.catch(() => {});
-    /** @type {() => void} */
     let commit = () => {};
-    /** @type {(e?: any) => void} */
     let rollback = () => {};
-    /** @type {Promise<void>} */
     const donePromise = new Promise((r1, r2) => {
       commit = r1;
       rollback = r2;
@@ -4337,7 +3892,7 @@ class Connection {
       }
       return donePromise;
     }).then(() => {}, () => {});
-    const handler = /** @type {TransactionHandler} */[abortedPromise, () => {
+    const handler = [abortedPromise, () => {
       commit();
       return dbiPromise;
     }, e => {
@@ -5652,7 +5207,7 @@ function toBool(v) {
   return !falseValues.has(v.toLowerCase());
 }
 
-/** @import { FieldDefine, Fields, LockType, Options, Queryable, Select } from './types' */
+/** @import { Action, FieldDefine, Fields, LockType, Options, Queryable, Select, Skip, TableConnect } from './types' */
 /** @import { WhereValue, Wheres } from './Where.mjs' */
 /**
  *
@@ -5710,6 +5265,7 @@ function selectFn(fn, select, newSelect) {
  * @template {object} [TB=object]
  * @typedef {object} QueryOptions
  * @property {string} [table]
+ * @property {TableConnect?} [connect]
  * @property {T} fields
  * @property {string} [pseudo]
  * @property {((a: object, b?: object | boolean) => TB)?} [build]
@@ -5739,6 +5295,8 @@ class Query extends Subquery {
   }
   /** @readonly @type {string | undefined} */
 
+  /** @readonly @type {TableConnect | null | undefined} */
+
   /** @readonly @type {T} */
 
   /** @readonly @type {string} */
@@ -5766,6 +5324,7 @@ class Query extends Subquery {
     super();
     if (options instanceof Query) {
       this.table = options.table;
+      this.connect = options.connect;
       this.fields = options.fields;
       this.pseudo = options.pseudo;
       this.#build = noBuild ? null : options.#build;
@@ -5776,11 +5335,13 @@ class Query extends Subquery {
     } else {
       const {
         table,
+        connect,
         fields,
         pseudo,
         build
       } = options;
       this.table = table;
+      this.connect = connect;
       this.fields = fields;
       this.pseudo = typeof pseudo === 'string' ? pseudo : '';
       this.#build = typeof build === 'function' ? build : null;