imodel 0.15.0 → 0.16.0

package/index.d.mts

@@ -1,5 +1,5 @@
 /*!
- * imodel v0.15.0
+ * imodel v0.16.0
  * (c) 2019-2026 undefined
  * @license undefined
  */
@@ -566,7 +566,7 @@ declare namespace SetValue {
 }
 
 interface VirtualTable<E extends object = object> {
-    insert(environment: Environment<E>, conn: IConnection<E>, columns: Record<string, DBColumn>, data: object[], key: string[]): PromiseLike<any[]>;
+    insert(environment: Environment<E>, conn: IConnection<E>, columns: Record<string, DBColumn>, data: object[], key: string[], ignoreConflict?: boolean): PromiseLike<any[]>;
     upsert(environment: Environment<E>, conn: IConnection<E>, columns: Record<string, DBColumn>, data: object[], key: string[], conflict: true | string[], conflictSet?: Record<string, SetValue>): PromiseLike<any[]>;
     update(environment: Environment<E>, conn: IConnection<E>, columns: Record<string, DBColumn>, update: Record<string, SetValue>, where?: WhereValue[] | null): PromiseLike<number>;
     updateReturn(environment: Environment<E>, conn: IConnection<E>, returning: string[], columns: Record<string, DBColumn>, update: Record<string, SetValue>, where?: WhereValue[] | null): PromiseLike<any[]>;
@@ -574,6 +574,7 @@ interface VirtualTable<E extends object = object> {
     updateManyReturn(environment: Environment<E>, conn: IConnection<E>, fields: Fields<keyof FieldType>, update: Record<string, any>, pKeys: string[], setKeys: string[], list: Record<string, any>[], where: WhereValue[], returning: string[]): PromiseLike<any[]>;
     count(environment: Environment<E>, conn: IConnection<E>, columns: Record<string, DBColumn>, where: WhereValue[]): PromiseLike<number>;
     find(environment: Environment<E>, conn: IConnection<E>, columns: Record<string, DBColumn>, argv: FindArg): PromiseLike<any[]>;
+    select(environment: Environment<E>, conn: IConnection<E>, select: SelectItem[]): PromiseLike<any[]>;
     delete(environment: Environment<E>, conn: IConnection<E>, columns: Record<string, DBColumn>, where?: WhereValue[] | null): PromiseLike<number>;
     deleteReturn(environment: Environment<E>, conn: IConnection<E>, returning: string[], columns: Record<string, DBColumn>, where?: WhereValue[] | null): PromiseLike<any[]>;
 }
@@ -629,7 +630,7 @@ type MainFieldType = keyof FieldType | TableDefine | null;
 type ToFieldType<T> = T extends keyof FieldType ? FieldType[T] : unknown;
 type FieldSpecificValue = (string | number | bigint | boolean)[] | string | number | bigint | boolean | null | typeof now | typeof uuid;
 type FieldSpecific = FieldSpecificValue | {
-    value: FieldSpecificValue;
+    value?: FieldSpecificValue;
     computed?(): PromiseLike<FieldSpecificValue> | FieldSpecificValue;
 };
 interface FieldDefineOption {
@@ -754,6 +755,7 @@ interface Options {
     limit?: number;
     update?: Record<string, SetValue>;
     alias?: string;
+    group?: string[];
 }
 interface Queryable<T extends Fields = Fields> extends TableDefine<T> {
     readonly options: Options;
@@ -787,6 +789,30 @@ interface FindArg {
     /** 最大返回数 */
     limit?: number;
 }
+interface JOIN {
+    type?: 'INNER' | 'LEFT' | 'RIGHT' | 'FULL' | 'CROSS';
+    table: string;
+    columns: Record<string, DBColumn>;
+    alias?: string;
+    condition?: WhereValue[];
+}
+interface SelectItem {
+    distinct?: boolean;
+    select: [string, Select][];
+    table: string;
+    columns: Record<string, DBColumn>;
+    alias?: string;
+    /** 匹配信息 */
+    where: WhereValue[];
+    group: string[];
+    having: WhereValue[];
+    /** 排序配置，true 表示逆序 */
+    sort: [field: string, desc: boolean][];
+    /** 偏移量 */
+    offset?: number;
+    /** 最大返回数 */
+    limit?: number;
+}
 type GetName = (table?: string) => string;
 interface DBColumn {
     type: string;
@@ -821,7 +847,7 @@ interface IConnection<E extends object = object> {
      */
     query(environment: Environment<E>, ...values: any): PromiseLike<any[]>;
     type(environment: Environment<E>, table: string): PromiseLike<TableType | null>;
-    insert(environment: Environment<E>, table: string, columns: Record<string, DBColumn>, data: object[], key: string[]): PromiseLike<any[]>;
+    insert(environment: Environment<E>, table: string, columns: Record<string, DBColumn>, data: object[], key: string[], ignoreConflict?: boolean): PromiseLike<any[]>;
     upsert(environment: Environment<E>, table: string, columns: Record<string, DBColumn>, data: object[], key: string[], conflict: true | string[], conflictSet?: Record<string, SetValue>): PromiseLike<any[]>;
     update(environment: Environment<E>, table: string, columns: Record<string, DBColumn>, update: Record<string, SetValue>, where?: WhereValue[] | null): PromiseLike<number>;
     updateReturn(environment: Environment<E>, returning: string[], table: string, columns: Record<string, DBColumn>, update: Record<string, SetValue>, where?: WhereValue[] | null): PromiseLike<any[]>;
@@ -829,6 +855,7 @@ interface IConnection<E extends object = object> {
     updateManyReturn(environment: Environment<E>, table: string, columns: Record<string, DBColumn>, update: Record<string, any>, pKeys: string[], setKeys: string[], list: Record<string, any>[], where: WhereValue[], returning: string[]): PromiseLike<any[]>;
     count(environment: Environment<E>, table: string, columns: Record<string, DBColumn>, where?: WhereValue[] | null): PromiseLike<number>;
     find(environment: Environment<E>, table: string, columns: Record<string, DBColumn>, argv: FindArg): PromiseLike<any[]>;
+    select(environment: Environment<E>, select: SelectItem[]): PromiseLike<any[]>;
     delete(environment: Environment<E>, table: string, columns: Record<string, DBColumn>, where?: WhereValue[] | null): PromiseLike<number>;
     deleteReturn(environment: Environment<E>, returning: string[], table: string, columns: Record<string, DBColumn>, where?: WhereValue[] | null): PromiseLike<any[]>;
     createTable(environment: Environment<E>, table: string, columns: Column<any>[]): PromiseLike<number>;
@@ -1533,42 +1560,166 @@ declare class Connection<E extends {} = {}> {
      */
     destroyMany(queryable: Queryable, update?: Record<string, SetValue> | boolean): Promise<number>;
     /**
-     * @template {object | object[]} T
+     * @template {object} T
+     * @overload
+     * @param {TableDefine} tableDefine
+     * @param {T} data
+     * @param {boolean} [ignoreConflict]
+     * @returns {Promise<T>}
+     */
+    insert<T extends unknown>(tableDefine: TableDefine, data: T, ignoreConflict?: boolean | undefined): Promise<T>;
+    /**
+     * @template {object} T
+     * @overload
+     * @param {TableDefine} tableDefine
+     * @param {T[]} data
+     * @param {boolean} [ignoreConflict]
+     * @returns {Promise<T[]>}
+     */
+    insert<T extends unknown>(tableDefine: TableDefine, data: T[], ignoreConflict?: boolean | undefined): Promise<T[]>;
+    /**
+     * @template {object} T
+     * @overload
      * @param {TableDefine} tableDefine
      * @param {T} data
      * @param {string[]} [keys]
-     * @returns {Promise<T extends object[] ? object[] : object>}
+     * @param {boolean} [ignoreConflict]
+     * @returns {Promise<T>}
+     */
+    insert<T extends unknown>(tableDefine: TableDefine, data: T, keys?: string[] | undefined, ignoreConflict?: boolean | undefined): Promise<T>;
+    /**
+     * @template {object} T
+     * @overload
+     * @param {TableDefine} tableDefine
+     * @param {T[]} data
+     * @param {string[]} [keys]
+     * @param {boolean} [ignoreConflict]
+     * @returns {Promise<T[]>}
+     */
+    insert<T extends unknown>(tableDefine: TableDefine, data: T[], keys?: string[] | undefined, ignoreConflict?: boolean | undefined): Promise<T[]>;
+    /**
+     * @template {object} T
+     * @overload
+     * @param {TableDefine} tableDefine
+     * @param {T} data
+     * @param {string[] | boolean} [keys]
+     * @param {boolean} [ignoreConflict]
+     * @returns {Promise<T>}
+     */
+    insert<T extends unknown>(tableDefine: TableDefine, data: T, keys?: boolean | string[] | undefined, ignoreConflict?: boolean | undefined): Promise<T>;
+    /**
+     * @template {object} T
+     * @overload
+     * @param {TableDefine} tableDefine
+     * @param {T[]} data
+     * @param {string[] | boolean} [keys]
+     * @param {boolean} [ignoreConflict]
+     * @returns {Promise<T[]>}
+     */
+    insert<T extends unknown>(tableDefine: TableDefine, data: T[], keys?: boolean | string[] | undefined, ignoreConflict?: boolean | undefined): Promise<T[]>;
+    /**
+     * @template {object} T
+     * @overload
+     * @param {TableDefine} tableDefine
+     * @param {T | T[]} data
+     * @param {string[] | boolean} [keys]
+     * @param {boolean} [ignoreConflict]
+     * @returns {Promise<T | T[]>}
      */
-    insert<T extends unknown>({ table, fields }: TableDefine, data: T, keys?: string[]): Promise<T extends object[] ? object[] : object>;
+    insert<T extends unknown>(tableDefine: TableDefine, data: T | T[], keys?: boolean | string[] | undefined, ignoreConflict?: boolean | undefined): Promise<T | T[]>;
     /**
-     * @template {object | object[]} T
+     * @template {object} T
      * @overload
      * @param {TableDefine} tableDefine
      * @param {T} data
      * @param {Record<string, SetValue>} [conflictSet]
-     * @returns {Promise<T extends object[] ? object[] : object>}
+     * @returns {Promise<T>}
      */
-    upsert<T extends unknown>(tableDefine: TableDefine, data: T, conflictSet?: Record<string, SetValue> | undefined): Promise<T extends object[] ? object[] : object>;
+    upsert<T extends unknown>(tableDefine: TableDefine, data: T, conflictSet?: Record<string, SetValue> | undefined): Promise<T>;
     /**
-     * @template {object | object[]} T
+     * @template {object} T
+     * @overload
+     * @param {TableDefine} tableDefine
+     * @param {T[]} data
+     * @param {Record<string, SetValue>} [conflictSet]
+     * @returns {Promise<T[]>}
+     */
+    upsert<T extends unknown>(tableDefine: TableDefine, data: T[], conflictSet?: Record<string, SetValue> | undefined): Promise<T[]>;
+    /**
+     * @template {object} T
      * @overload
      * @param {TableDefine} tableDefine
      * @param {T} data
-     * @param {string[]} [keys]
+     * @param {null | string[]} [keys]
+     * @param {Record<string, SetValue>} [conflictSet]
+     * @returns {Promise<T>}
+     */
+    upsert<T extends unknown>(tableDefine: TableDefine, data: T, keys?: string[] | null | undefined, conflictSet?: Record<string, SetValue> | undefined): Promise<T>;
+    /**
+     * @template {object} T
+     * @overload
+     * @param {TableDefine} tableDefine
+     * @param {T[]} data
+     * @param {null | string[]} [keys]
+     * @param {Record<string, SetValue>} [conflictSet]
+     * @returns {Promise<T[]>}
+     */
+    upsert<T extends unknown>(tableDefine: TableDefine, data: T[], keys?: string[] | null | undefined, conflictSet?: Record<string, SetValue> | undefined): Promise<T[]>;
+    /**
+     * @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 extends object[] ? object[] : object>}
+     * @returns {Promise<T>}
      */
-    upsert<T extends unknown>(tableDefine: TableDefine, data: T, keys?: string[] | undefined, conflictSet?: Record<string, SetValue> | undefined): Promise<T extends object[] ? object[] : object>;
+    upsert<T extends unknown>(tableDefine: TableDefine, data: T, keys?: string[] | null | undefined, conflictKeys?: boolean | string[] | undefined, conflictSet?: Record<string, SetValue> | undefined): Promise<T>;
     /**
-     * @template {object | object[]} T
+     * @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[]>}
+     */
+    upsert<T extends unknown>(tableDefine: TableDefine, data: T[], keys?: string[] | null | undefined, conflictKeys?: boolean | string[] | undefined, conflictSet?: Record<string, SetValue> | undefined): Promise<T[]>;
+    /**
+     * @template {object} T
      * @overload
      * @param {TableDefine} tableDefine
      * @param {T} data
-     * @param {string[] | Record<string, SetValue>} [keys]
+     * @param {null | string[] | boolean | Record<string, SetValue>} [keys]
+     * @param {string[] | boolean | Record<string, SetValue>} [conflictKeys]
      * @param {Record<string, SetValue>} [conflictSet]
-     * @returns {Promise<T extends object[] ? object[] : object>}
+     * @returns {Promise<T>}
      */
-    upsert<T extends unknown>(tableDefine: TableDefine, data: T, keys?: string[] | Record<string, SetValue> | undefined, conflictSet?: Record<string, SetValue> | undefined): Promise<T extends object[] ? object[] : object>;
+    upsert<T extends unknown>(tableDefine: TableDefine, data: T, keys?: boolean | string[] | Record<string, SetValue> | null | undefined, conflictKeys?: boolean | string[] | Record<string, SetValue> | undefined, conflictSet?: Record<string, SetValue> | undefined): Promise<T>;
+    /**
+     * @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[]>}
+     */
+    upsert<T extends unknown>(tableDefine: TableDefine, data: T[], keys?: boolean | string[] | Record<string, SetValue> | null | undefined, conflictKeys?: boolean | string[] | Record<string, SetValue> | undefined, conflictSet?: Record<string, SetValue> | undefined): Promise<T[]>;
+    /**
+     * @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[]>}
+     */
+    upsert<T extends unknown>(tableDefine: TableDefine, data: T | T[], keys?: boolean | string[] | Record<string, SetValue> | null | undefined, conflictKeys?: boolean | string[] | Record<string, SetValue> | undefined, conflictSet?: Record<string, SetValue> | undefined): Promise<T | T[]>;
     /**
      * @param {TableDefine} tableDefine
      * @param {Record<string, any>} update
@@ -1937,6 +2088,11 @@ declare class Query<T extends Fields, TB extends unknown = any> implements Query
      * @returns {this}
      */
     primary(primary?: any, ...args: any[]): this;
+    /**
+     *
+     * @param  {...string | string[]} groups
+     */
+    groupBy(...groups: (string | string[])[]): this;
     /**
      *
      * @param {object} a
@@ -2362,4 +2518,4 @@ declare function field<T extends MainFieldType>(type: T, options: {
 declare function setDevelopment(d?: boolean): void;
 declare let isDevelopment: boolean;
 
-export { Build, type ClassDecorator, type Column, type ColumnOptions, Connection, type Constraint, Create, type DBColumn, type DBIndex, type DBTable, Destroy, type Environment, type FieldDecorator, type FieldDefine, type FieldDefineOption, type FieldDefineType, type FieldSpecific, type FieldSpecificValue, type FieldType, type FieldTypeDefine, type FieldValue, type Fields, type FindArg, type FindRange, type GetName, type Hook, type Hooks, type IConnection, type Index, type IndexInfo, type IndexOptions, type Join, type JoinType, type MainFieldType, type MaybePromise, type MethodDecorator, Model, type Options, PseudoDestroy, Query, type QueryOptions, type Queryable, Save, Scene, Select, SetValue, type Skip, Submodel, type Support, type TableDefine, type TableType, type ToFieldType, type ToType, type TransactionFn, type VirtualTable, Where, type WhereItem, type WhereLike, type WhereOr, type WhereRaw, type WhereValue, type Wheres, afterCreate, afterCreateMany, afterDelete, afterUpdate, beforeCreate, beforeCreateMany, beforeDelete, beforeUpdate, coefficient, column, creating, decrement, defaultValue, field as define, deleted, deleting, divide, field$1 as field, getPrimaryFields, getPrimaryKeys, immutable, increment, index, isDevelopment, isPseudo, model, multiply, now, primary, prop, pseudo, setDevelopment, sort, model as submodel, toNot, toPrimaries, toPrimary, uncreatable, undeleted, updating, uuid, values, where, withDeleted };
+export { Build, type ClassDecorator, type Column, type ColumnOptions, Connection, type Constraint, Create, type DBColumn, type DBIndex, type DBTable, Destroy, type Environment, type FieldDecorator, type FieldDefine, type FieldDefineOption, type FieldDefineType, type FieldSpecific, type FieldSpecificValue, type FieldType, type FieldTypeDefine, type FieldValue, type Fields, type FindArg, type FindRange, type GetName, type Hook, type Hooks, type IConnection, type Index, type IndexInfo, type IndexOptions, type JOIN, type Join, type JoinType, type MainFieldType, type MaybePromise, type MethodDecorator, Model, type Options, PseudoDestroy, Query, type QueryOptions, type Queryable, Save, Scene, Select, type SelectItem, SetValue, type Skip, Submodel, type Support, type TableDefine, type TableType, type ToFieldType, type ToType, type TransactionFn, type VirtualTable, Where, type WhereItem, type WhereLike, type WhereOr, type WhereRaw, type WhereValue, type Wheres, afterCreate, afterCreateMany, afterDelete, afterUpdate, beforeCreate, beforeCreateMany, beforeDelete, beforeUpdate, coefficient, column, creating, decrement, defaultValue, field as define, deleted, deleting, divide, field$1 as field, getPrimaryFields, getPrimaryKeys, immutable, increment, index, isDevelopment, isPseudo, model, multiply, now, primary, prop, pseudo, setDevelopment, sort, model as submodel, toNot, toPrimaries, toPrimary, uncreatable, undeleted, updating, uuid, values, where, withDeleted };

package/index.mjs

@@ -1,5 +1,5 @@
 /*!
- * imodel v0.15.0
+ * imodel v0.16.0
  * (c) 2019-2026 undefined
  * @license undefined
  */
@@ -733,13 +733,10 @@ async function getSpecificValue(val) {
     computed,
     value
   } = val;
-  if (value === void 0) {
-    return;
-  }
   if (typeof computed === 'function') {
     const value = await computed();
     if (value !== void 0) {
-      return;
+      return value;
     }
   }
   return value;
@@ -2937,84 +2934,211 @@ class Connection {
     return pseudoDeleteMany(conn, queryable, update, this.#env);
   }
   /**
-   * @template {object | object[]} T
+   * @template {object} T
+   * @overload
    * @param {TableDefine} tableDefine
    * @param {T} data
+   * @param {boolean} [ignoreConflict]
+   * @returns {Promise<T>}
+   */
+  /**
+   * @template {object} T
+   * @overload
+   * @param {TableDefine} tableDefine
+   * @param {T[]} data
+   * @param {boolean} [ignoreConflict]
+   * @returns {Promise<T[]>}
+   */
+  /**
+   * @template {object} T
+   * @overload
+   * @param {TableDefine} tableDefine
+   * @param {T} data
+   * @param {string[]} [keys]
+   * @param {boolean} [ignoreConflict]
+   * @returns {Promise<T>}
+   */
+  /**
+   * @template {object} T
+   * @overload
+   * @param {TableDefine} tableDefine
+   * @param {T[]} data
    * @param {string[]} [keys]
-   * @returns {Promise<T extends object[] ? object[] : object>}
+   * @param {boolean} [ignoreConflict]
+   * @returns {Promise<T[]>}
+   */
+  /**
+   * @template {object} T
+   * @overload
+   * @param {TableDefine} tableDefine
+   * @param {T} data
+   * @param {string[] | boolean} [keys]
+   * @param {boolean} [ignoreConflict]
+   * @returns {Promise<T>}
+   */
+  /**
+   * @template {object} T
+   * @overload
+   * @param {TableDefine} tableDefine
+   * @param {T[]} data
+   * @param {string[] | boolean} [keys]
+   * @param {boolean} [ignoreConflict]
+   * @returns {Promise<T[]>}
+   */
+  /**
+   * @template {object} T
+   * @overload
+   * @param {TableDefine} tableDefine
+   * @param {T | T[]} data
+   * @param {string[] | boolean} [keys]
+   * @param {boolean} [ignoreConflict]
+   * @returns {Promise<T | T[]>}
+   */
+  /**
+   * @template {object} T
+   * @param {TableDefine} tableDefine
+   * @param {T | T[]} data
+   * @param {string[] | boolean} [keys]
+   * @param {boolean} [ignoreConflict]
+   * @returns {Promise<T | T[]>}
    */
   async insert({
     table,
     fields
-  }, data, keys) {
+  }, data, keys, ignoreConflict) {
     const [columns, fieldColumns] = toColumns(fields);
     const isArray = Array.isArray(data);
-    const insertValues = (isArray ? data : [data]).map(d => getInsertValue(d, columns, fieldColumns, {
+    const insertValues = (isArray ? data : [data]
+    // @ts-ignore
+    ).map(d => getInsertValue(d, columns, fieldColumns, {
       uncreatable: true
     }));
     if (!insertValues.length) {
       throw new Error();
     }
-    let insertKeys = fieldColumns ? [...new Set(keys || [])].map(k => fieldColumns[k]).filter(Boolean) : [...new Set(keys || [])].filter(k => k in columns);
+    const allKeys = Array.isArray(keys) ? [...new Set(keys || [])] : [];
+    let insertKeys = fieldColumns ? allKeys.map(k => fieldColumns[k]).filter(Boolean) : allKeys.filter(k => k in columns);
     if (!insertKeys.length && !isArray) {
       insertKeys = Object.entries(insertValues[0]).filter(([k, v]) => v !== undefined && k in columns).map(([k]) => k);
     }
     if (!insertKeys.length) {
       insertKeys = Object.entries(columns).map(v => v[0]);
     }
+    const ignore = Boolean(Array.isArray(keys) ? ignoreConflict : keys);
     const conn = await this.#getConnection();
-    const result = table && typeof table === 'object' ? await table.insert(this.#env, conn, columns, insertValues, insertKeys) : await conn.insert(this.#env, table || '', columns, insertValues, insertKeys);
+    const result = table && typeof table === 'object' ? await table.insert(this.#env, conn, columns, insertValues, insertKeys, ignore) : await conn.insert(this.#env, table || '', columns, insertValues, insertKeys, ignore);
     const list = toFieldList(result, fieldColumns);
     // @ts-ignore
     return isArray ? list : list[0];
   }
   /**
-   * @template {object | object[]} T
+   * @template {object} T
    * @overload
    * @param {TableDefine} tableDefine
    * @param {T} data
    * @param {Record<string, SetValue>} [conflictSet]
-   * @returns {Promise<T extends object[] ? object[] : object>}
+   * @returns {Promise<T>}
    */
   /**
-   * @template {object | object[]} T
+   * @template {object} T
+   * @overload
+   * @param {TableDefine} tableDefine
+   * @param {T[]} data
+   * @param {Record<string, SetValue>} [conflictSet]
+   * @returns {Promise<T[]>}
+   */
+  /**
+   * @template {object} T
    * @overload
    * @param {TableDefine} tableDefine
    * @param {T} data
-   * @param {string[]} [keys]
+   * @param {null | string[]} [keys]
    * @param {Record<string, SetValue>} [conflictSet]
-   * @returns {Promise<T extends object[] ? object[] : object>}
+   * @returns {Promise<T>}
    */
   /**
-   * @template {object | object[]} T
+   * @template {object} T
+   * @overload
+   * @param {TableDefine} tableDefine
+   * @param {T[]} data
+   * @param {null | string[]} [keys]
+   * @param {Record<string, SetValue>} [conflictSet]
+   * @returns {Promise<T[]>}
+   */
+  /**
+   * @template {object} T
    * @overload
    * @param {TableDefine} tableDefine
    * @param {T} data
-   * @param {string[] | Record<string, SetValue>} [keys]
+   * @param {null | string[]} [keys]
+   * @param {string[] | boolean} [conflictKeys]
+   * @param {Record<string, SetValue>} [conflictSet]
+   * @returns {Promise<T>}
+   */
+  /**
+   * @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 extends object[] ? object[] : object>}
+   * @returns {Promise<T[]>}
    */
   /**
-   * @template {object | object[]} T
+   * @template {object} T
+   * @overload
    * @param {TableDefine} tableDefine
    * @param {T} data
-   * @param {string[] | Record<string, SetValue>} [keys]
+   * @param {null | string[] | boolean | Record<string, SetValue>} [keys]
+   * @param {string[] | boolean | Record<string, SetValue>} [conflictKeys]
    * @param {Record<string, SetValue>} [conflictSet]
-   * @returns {Promise<T extends object[] ? object[] : object>}
+   * @returns {Promise<T>}
+   */
+  /**
+   * @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[]>}
+   */
+  /**
+   * @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[]>}
+   */
+  /**
+   * @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[]>}
    */
   async upsert({
     table,
     fields
-  }, data, keys, conflictSet) {
+  }, data, keys, conflictKeys, conflictSet) {
     const [columns, fieldColumns, baseFields] = toColumns(fields);
     const isArray = Array.isArray(data);
-    const insertValues = (isArray ? data : [data]).map(d => getInsertValue(d, columns, fieldColumns, {
+    const insertValues = (isArray ? data : [data]
+    // @ts-ignore
+    ).map(d => getInsertValue(d, columns, fieldColumns, {
       uncreatable: true
     }));
     if (!insertValues.length) {
       throw new Error();
     }
-    const set = Array.isArray(keys) ? conflictSet : keys;
+    const set = [keys, conflictKeys, conflictSet].find(/** @type {(v: any) => v is Record<string, SetValue>} */v => v && !Array.isArray(v) && typeof v === 'object');
     const saveKeys = Array.isArray(keys) ? [...new Set(keys)] : [];
     let insertKeys = fieldColumns ? saveKeys.map(k => fieldColumns[k]).filter(Boolean) : saveKeys.filter(k => k in columns);
     if (!insertKeys.length && !isArray) {
@@ -3023,9 +3147,9 @@ class Connection {
     if (!insertKeys.length) {
       insertKeys = Object.entries(columns).map(v => v[0]);
     }
-    const primaryFields = baseFields.filter(([, v]) => v.primary).sort(([, a], [, b]) => Number(a.primary) - Number(b.primary)).map(([v]) => v);
+    const conflict = Array.isArray(conflictKeys) || conflictKeys === true ? conflictKeys : baseFields.filter(([, v]) => v.primary).sort(([, a], [, b]) => Number(a.primary) - Number(b.primary)).map(([v]) => v);
     const conn = await this.#getConnection();
-    const result = table && typeof table === 'object' ? await table.upsert(this.#env, conn, columns, insertValues, insertKeys, primaryFields, set) : await conn.upsert(this.#env, table || '', columns, insertValues, insertKeys, primaryFields, set);
+    const result = table && typeof table === 'object' ? await table.upsert(this.#env, conn, columns, insertValues, insertKeys, conflict, set) : await conn.upsert(this.#env, table || '', columns, insertValues, insertKeys, conflict, set);
     const list = toFieldList(result, fieldColumns);
     // @ts-ignore
     return isArray ? list : list[0];
@@ -3176,19 +3300,27 @@ class Connection {
     const {
       sort
     } = options;
-    const result = table && typeof table === 'object' ? await table.find(this.#env, conn, columns, {
+    const result = table && typeof table === 'object' ? await table.select(this.#env, conn, [{
+      table: '',
+      columns,
       offset,
       limit,
       where,
       select,
-      sort: sort?.length ? sort2column(sort, fieldColumns) : getDefaultSort(columns)
-    }) : await conn.find(this.#env, table || '', columns, {
+      sort: sort?.length ? sort2column(sort, fieldColumns) : getDefaultSort(columns),
+      group: options.group || [],
+      having: []
+    }]) : await conn.select(this.#env, [{
+      table: table || '',
+      columns,
       offset,
       limit,
       where,
       select,
-      sort: sort?.length ? sort2column(sort, fieldColumns) : getDefaultSort(columns)
-    });
+      sort: sort?.length ? sort2column(sort, fieldColumns) : getDefaultSort(columns),
+      group: options.group || [],
+      having: []
+    }]);
     return result;
   }
   /**
@@ -4641,7 +4773,7 @@ function selectFn(fn, select, newSelect) {
     if (typeof s === 'string') {
       select[s] = {
         field: s,
-        fn: 'sum'
+        fn
       };
       continue;
     }
@@ -5116,6 +5248,14 @@ class Query {
     m.#primary = primary;
     return m;
   }
+  /**
+   *
+   * @param  {...string | string[]} groups
+   */
+  groupBy(...groups) {
+    this.#options.group = [this.#options.group || [], groups].flat(2);
+    return this;
+  }
 }
 
 /** @import { Fields, IndexInfo, FieldDefine } from './types' */

package/migrate.d.mts

@@ -1,5 +1,5 @@
 /*!
- * imodel v0.15.0
+ * imodel v0.16.0
  * (c) 2019-2026 undefined
  * @license undefined
  */

package/migrate.mjs

@@ -1,5 +1,5 @@
 /*!
- * imodel v0.15.0
+ * imodel v0.16.0
  * (c) 2019-2026 undefined
  * @license undefined
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "imodel",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "main": "index.mjs",
   "type": "module",
   "repository": {