imodel 0.20.0 → 0.20.2

package/index.mjs

@@ -1,5 +1,5 @@
 /*!
- * imodel v0.20.0
+ * imodel v0.20.2
  * (c) 2019-2026 猛火Fierflame
  * @license MIT
  */
@@ -244,12 +244,6 @@ function setDefaultOptions(v) {
   return v;
 }
 
-const Destroy = Symbol();
-const PseudoDestroy = Symbol();
-const Save = Symbol();
-const Create = Symbol();
-const Build = Symbol();
-
 /** @import { TableDefine, FieldDefine } from '../types/table' */
 /** @import { DBIndex, DBTable } from '../types/connection' */
 /**
@@ -380,6 +374,12 @@ function table2db(tables) {
   return allTables;
 }
 
+const Destroy = Symbol();
+const PseudoDestroy = Symbol();
+const Save = Symbol();
+const Create = Symbol();
+const Build = Symbol();
+
 function signal2promise(signal) {
   return new Promise((_, r) => {
     if (signal.aborted) {
@@ -428,7 +428,46 @@ function createInterface (connPromise, baseTransaction) {
       // TODO: 检测层数
     }
   }
+  function build(p, data, saved) {
+    if (typeof p[Build] === 'function') {
+      return p[Build](data, saved || false, {
+        isDevelopment,
+        values,
+        errors
+      });
+    }
+    if (typeof saved === 'boolean') {
+      return {
+        ...data
+      };
+    }
+    return {
+      ...data,
+      ...saved
+    };
+  }
   const ci = {
+    build,
+    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);
@@ -999,41 +1038,43 @@ const withDeleted = Symbol();
 /** @typedef {typeof withDeleted} withDeleted  */
 /** @typedef {deleted | undeleted | withDeleted} FindRange */
 
-/** @import { Options, Queryable } from '../types' */
-/**
- *
- * @param {Partial<Queryable>} queryable
- * @returns {Options}
- */
-function getOptions({
+function getPseudoWhere({
   fields,
-  pseudo,
-  options: modelOptions
-}) {
-  const options = {
-    where: [],
-    ...modelOptions
-  };
+  pseudo
+}, range) {
   if (!pseudo || !fields) {
-    return options;
+    return null;
   }
   if (!(pseudo in fields)) {
-    return options;
+    return null;
   }
-  if (options.range === undeleted) {
-    options.where = [...options.where, {
+  if (range === undeleted) {
+    return {
       field: pseudo,
       operator: '<>',
       value: 0
-    }];
-  } else if (options.range !== withDeleted) {
-    options.where = [...options.where, {
+    };
+  } else if (range !== withDeleted) {
+    return {
       field: pseudo,
       operator: '=',
       value: 0
-    }];
+    };
+  }
+  return null;
+}
+function getOptions(queryable) {
+  const pseudoWhere = getPseudoWhere(queryable, queryable.options?.range);
+  if (!pseudoWhere) {
+    return {
+      where: [],
+      ...queryable.options
+    };
   }
-  return options;
+  return {
+    ...queryable.options,
+    where: [...(queryable.options?.where || []), pseudoWhere]
+  };
 }
 
 function count (queryable) {
@@ -2486,7 +2527,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' */
 
 /**
@@ -2672,23 +2713,20 @@ async function search$1(conn, that, p, returnFields, skip) {
 
 /* eslint-disable max-len */
 
+/** @deprecated */
 function find (sql, skip) {
   return {
     connect: sql.connect,
-    async invoke(connect, connection, env) {
+    async invoke(connect, connection) {
       const conn = await connect();
       const result = await search$1(conn, connection, sql, true, skip);
-      if (typeof sql[Build] !== 'function') {
-        return result;
-      }
-      const R = sql[Build].bind(sql);
-      return result.map(it => R(it, true, env));
+      return result.map(it => conn.build(sql, it, true));
     }
   };
 }
 
-/** @import Connection from './index.mjs' */
-/** @import { Environment, TableDefine, Skip, SelectItem, ConnectionInterface, BaseEnvironment } from '../types' */
+/** @import Connection from './index.mts' */
+/** @import { TableDefine, Skip, SelectItem, ConnectionInterface } from '../types' */
 
 /**
  *
@@ -2696,11 +2734,10 @@ function find (sql, skip) {
  * @param {ConnectionInterface} conn
  * @param {Connection} that
  * @param {T} p
- * @param {BaseEnvironment} env
  * @param {Skip} [skip]
  * @returns {Promise<any>}
  */
-async function first$1(conn, that, p, env, skip) {
+async function first$1(conn, that, p, skip) {
   const {
     table,
     fields
@@ -2735,18 +2772,15 @@ async function first$1(conn, that, p, env, skip) {
   if (!item) {
     return null;
   }
-  if (typeof p[Build] !== 'function') {
-    return item;
-  }
-  return p[Build](item, true, env);
+  return conn.build(p, item);
 }
 
 function first (sql, skip) {
   return {
     connect: sql.connect,
-    async invoke(connect, connection, env) {
+    async invoke(connect, connection) {
       const conn = await connect();
-      return first$1(conn, connection, sql, env, skip);
+      return first$1(conn, connection, sql, skip);
     }
   };
 }
@@ -3343,6 +3377,7 @@ function save (model, data, newData, skip) {
   };
 }
 
+/** @deprecated */
 function search (sql, fields, skip) {
   return {
     connect: sql.connect,
@@ -3396,6 +3431,7 @@ function toSelect(queryable, lockable) {
   };
 }
 
+/** @deprecated */
 function select (queryable) {
   return {
     connect: queryable.connect,
@@ -3555,6 +3591,91 @@ function upsert ({
   };
 }
 
+const falseValues = new Set(['', '0', 'n', 'f', 'no', 'off', 'false', '否', '不', '假', '不是', '不行', '不可以']);
+
+/**
+ *
+ * @param {any} v
+ * @returns
+ */
+function toBool(v) {
+  if (typeof v !== 'string') {
+    return Boolean(v);
+  }
+  return !falseValues.has(v.toLowerCase());
+}
+
+/** @import Connection from './index.mts' */
+/** @import { TableDefine, Skip, SelectItem, ConnectionInterface } from '../types' */
+
+function get (model, primary, options) {
+  return {
+    connect: model.connect,
+    async invoke(connect, connection) {
+      const primaryFields = Object.entries(model.fields).filter(([, v]) => v.primary).sort(([, a], [, b]) => Number(a.primary) - Number(b.primary));
+      if (!primaryFields.length) {
+        throw new Error('no primary key');
+      }
+      const wheres = new Where();
+      if (primaryFields.length === 1) {
+        const [[field]] = primaryFields;
+        wheres.and(field, primary);
+      } else if (typeof primary === 'object') {
+        for (const [p] of primaryFields) {
+          wheres.and(p, primary[p]);
+        }
+      } else {
+        const values = `${primary}`.split('$');
+        if (values.length !== primaryFields.length) ;
+        for (const [i, [p, {
+          type
+        }]] of primaryFields.entries()) {
+          const value = values[i] ?? null;
+          const val = type !== 'bool' || value === null ? value : toBool(value);
+          wheres.and(p, val);
+        }
+      }
+      const whereValues = Where.parseParams([wheres]) || [];
+      const pseudoWhere = getPseudoWhere(model, options?.range);
+      if (pseudoWhere) {
+        whereValues.push(pseudoWhere);
+      }
+      const {
+        table,
+        fields
+      } = model;
+      const lock = options?.lock;
+      const [columns, fieldColumns, tableFields] = toColumns(fields);
+      const where = where2column(whereValues, fieldColumns);
+      where.push(...getFixedValueWhere(columns));
+      const whereHook = !options?.skipWhere && (await model.hooks?.where?.(connection, model));
+      if (whereHook) {
+        where.push(...where2column(Where.parse(whereHook), fieldColumns));
+      }
+      /** @type {SelectItem} */
+      const selects = {
+        table: typeof table === 'string' ? table : '',
+        columns,
+        where,
+        limit: 1,
+        sort: [],
+        select: select2column(columns, fieldColumns),
+        group: [],
+        having: [],
+        lock: options?.lock
+      };
+      const conn = await connect();
+      const list = await conn.select(selects);
+      const baseFieldSet = new Set(Object.keys(fieldColumns || columns));
+      const [item] = await findSub(conn, list, tableFields, baseFieldSet, lock);
+      if (!item) {
+        return null;
+      }
+      return conn.build(model, item);
+    }
+  };
+}
+
 var index$1 = /*#__PURE__*/Object.freeze({
 	__proto__: null,
 	completelyDestroy: completelyDestroy,
@@ -3566,6 +3687,7 @@ var index$1 = /*#__PURE__*/Object.freeze({
 	destroyMany: destroyMany,
 	find: find,
 	first: first,
+	get: get,
 	insert: insert,
 	pseudoDestroy: pseudoDestroy,
 	save: save,
@@ -3578,50 +3700,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,693 +3732,245 @@ 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);
-    }
-    if (typeof saved === 'boolean') {
-      return {
-        ...data
-      };
-    }
-    return {
-      ...data,
-      ...saved
-    };
+    return this.#interface.build(p, data, 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 +3983,7 @@ class Connection {
       }
       return donePromise;
     }).then(() => {}, () => {});
-    const handler = /** @type {TransactionHandler} */[abortedPromise, () => {
+    const handler = [abortedPromise, () => {
       commit();
       return dbiPromise;
     }, e => {
@@ -5638,21 +5284,7 @@ function coefficient(...value) {
   };
 }
 
-const falseValues = new Set(['', '0', 'n', 'f', 'no', 'off', 'false', '否', '不', '假', '不是', '不行', '不可以']);
-
-/**
- *
- * @param {any} v
- * @returns
- */
-function toBool(v) {
-  if (typeof v !== 'string') {
-    return Boolean(v);
-  }
-  return !falseValues.has(v.toLowerCase());
-}
-
-/** @import { FieldDefine, Fields, LockType, Options, Queryable, Select } from './types' */
+/** @import { Action, FieldDefine, Fields, FieldValue, LockType, Options, Queryable, Select, Skip, TableConnect } from './types' */
 /** @import { WhereValue, Wheres } from './Where.mjs' */
 /**
  *
@@ -5710,14 +5342,16 @@ 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]
  */
 /**
  * @template {Fields} T
- * @template {object} [TB=object]
+ * @template {object | never} [TB=object]
  * @implements {Queryable<T>}
+ * @implements {Action<any[]>}
  */
 class Query extends Subquery {
   /**
@@ -5739,6 +5373,8 @@ class Query extends Subquery {
   }
   /** @readonly @type {string | undefined} */
 
+  /** @readonly @type {TableConnect | null | undefined} */
+
   /** @readonly @type {T} */
 
   /** @readonly @type {string} */
@@ -5766,6 +5402,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 +5413,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;
@@ -6190,6 +5829,41 @@ class Query extends Subquery {
     this.#options.lock = type === 'S' || type === 'X' ? type : null;
     return this;
   }
+  async invoke(connect) {
+    const selects = toSelect(this, true);
+    const conn = await connect();
+    return conn.select(selects);
+  }
+  /**
+   * @param {string[]} fields
+   * @param {Skip} [skip]
+   * @returns {Action<FieldValue<T>[]>}
+   */
+  search(fields, skip) {
+    return {
+      connect: this.connect,
+      invoke: async (connect, connection) => {
+        const returnFields = Array.isArray(fields) ? fields : [];
+        const conn = await connect();
+        const result = search$1(conn, connection, this, returnFields, skip);
+        return /** @type {any} */result;
+      }
+    };
+  }
+  /**
+   * @param {Skip} [skip]
+   * @returns {Action<(FieldValue<T> | TB)[]>}
+   */
+  find(skip) {
+    return {
+      connect: this.connect,
+      invoke: async (connect, connection) => {
+        const conn = await connect();
+        const result = await search$1(conn, connection, this, true, skip);
+        return result.map(it => conn.build(this, it, true));
+      }
+    };
+  }
 }
 
 /** @import { Fields, IndexInfo, FieldDefine } from './types' */
@@ -7546,4 +7220,4 @@ function field(type, {
   };
 }
 
-export { Build, CheckViolationError, Connection, ConnectionError, Create, Destroy, ForeignKeyViolationError, InvalidInputSyntaxError, Model, NotNullViolationError, OperatorMismatchError, PseudoDestroy, Query, Save, Scene, Submodel, UniqueViolationError, Where, index$1 as actions, afterCreate, afterCreateMany, afterDelete, afterUpdate, beforeCreate, beforeCreateMany, beforeDelete, beforeUpdate, bindHooks, coefficient, column, completelyDestroy, count, create, creating, decrement, defaultValue, field as define, _delete as delete, deleteReturn, deleted, deleting, destroy, destroyMany, divide, field$1 as field, find, first, getPrimaryFields, getPrimaryKeys, hooks, immutable, increment, index, insert, isDevelopment, isPseudo, mergeHooks, model, multiply, now, primary, prop, pseudo, pseudoDestroy, save, search, select, setDevelopment, sort, model as submodel, toBool, toNot, toPrimaries, toPrimary, uncreatable, undeleted, update, updateList, updateListReturn, updateReturn, updating, upsert, uuid, values, where, withDeleted };
+export { index$1 as Action, Build, CheckViolationError, Connection, ConnectionError, Create, Destroy, ForeignKeyViolationError, InvalidInputSyntaxError, Model, NotNullViolationError, OperatorMismatchError, PseudoDestroy, Query, Save, Scene, Submodel, Subquery, UniqueViolationError, Where, index$1 as actions, afterCreate, afterCreateMany, afterDelete, afterUpdate, beforeCreate, beforeCreateMany, beforeDelete, beforeUpdate, bindHooks, coefficient, column, completelyDestroy, count, create, creating, decrement, defaultValue, field as define, _delete as delete, deleteReturn, deleted, deleting, destroy, destroyMany, divide, field$1 as field, find, first, get, getPrimaryFields, getPrimaryKeys, hooks, immutable, increment, index, insert, isDevelopment, isPseudo, mergeHooks, model, multiply, now, primary, prop, pseudo, pseudoDestroy, save, search, select, setDevelopment, sort, model as submodel, toBool, toNot, toPrimaries, toPrimary, uncreatable, undeleted, update, updateList, updateListReturn, updateReturn, updating, upsert, uuid, values, where, withDeleted };