@asla/yoursql 0.6.5 → 0.7.0

package/dist/mod.d.ts

@@ -1,7 +1,8 @@
 export * from "./sql_value/db_type.ts";
 export * from "./sql_value/sql_value.ts";
 export * from "./select/type.ts";
-export * from "./select/select.ts";
+export * from "./select/DbTable.ts";
+export * from "./select/query_link.ts";
 export * from "./select/selectable.ts";
 export * from "./select/TableQuery.ts";
 export * from "./util.ts";

package/dist/mod.js

@@ -79,6 +79,45 @@ function condition(conditions, type = "AND") {
         return;
     }
 }
+function createUpdateSetFromObject(set) {
+    const updateKey = Object.keys(set);
+    let i = 0;
+    let key;
+    let value;
+    let sql;
+    for (; i < updateKey.length; i++) {
+        key = updateKey[i];
+        value = set[key];
+        if (value === undefined)
+            continue;
+        if (typeof value === "string") {
+            if (value) {
+                sql = "SET\n" + key + "= " + value;
+                break;
+            }
+        }
+        else
+            throw new TypeError(`key ${key} 类型错误(${typeof value})`);
+    }
+    if (sql) {
+        i++;
+        for (; i < updateKey.length; i++) {
+            key = updateKey[i];
+            value = set[key];
+            if (value === undefined)
+                continue;
+            if (typeof value === "string") {
+                if (value)
+                    sql += "," + key + "= " + value;
+            }
+            else
+                throw new TypeError(`key ${key} 类型错误(${typeof value})`);
+        }
+        return sql;
+    }
+    else
+        throw new Error("值不能为空");
+}
 
 /**
  * 获取对象数组中的 key 的集合
@@ -249,22 +288,6 @@ var _SqlQueryStatement_sql;
  */
 class SqlSelectable {
 }
-/**
- * 数据库表
- * @public
- */
-class DbTable extends SqlSelectable {
-    constructor(name) {
-        super();
-        this.name = name;
-    }
-    toSelect() {
-        return this.name;
-    }
-    toString() {
-        return this.name;
-    }
-}
 /**
  * SELECT 以及 UPDATE、DELETE、INSERT INTO 带结果的 SQL 语句
  * @public
@@ -371,7 +394,10 @@ class SqlValuesCreator {
             case "object": {
                 if (value instanceof String)
                     return value.toString();
-                return this.getObjectType(value).call(this, value);
+                const Class = this.getClassType(value);
+                if (Class)
+                    return this._map.get(Class).call(this, value);
+                return this.defaultObject(value);
             }
             case "undefined":
                 return "DEFAULT";
@@ -643,10 +669,21 @@ class AfterSelectImpl extends SqlQueryStatement {
     }
     limit(limit, offset) {
         let sql = this.toString();
-        if (limit)
-            sql += "\nLIMIT " + limit;
-        if (offset)
-            sql += "\nOFFSET " + offset;
+        let type;
+        if (limit) {
+            type = typeof limit;
+            if (type === "number" || type === "bigint")
+                sql += "\nLIMIT " + limit;
+            else
+                throw new TypeError("limit 必须是个整数：" + limit);
+        }
+        if (offset) {
+            type = typeof offset;
+            if (type === "number" || type === "bigint")
+                sql += "\nOFFSET " + offset;
+            else
+                throw new TypeError("offset 必须是个整数：" + limit);
+        }
         return new SqlQueryStatement(sql);
     }
 }
@@ -708,93 +745,170 @@ _a = Selection, _Selection_sql = new WeakMap(), _Selection_instances = new WeakS
     return new _a(sql);
 };
 
-/** @public */
-class DbTableQuery extends DbTable {
-    constructor(name, statement) {
-        super(name);
-        this.statement = statement;
+var _AfterInsert_sql;
+class AfterUpdateOrReturn extends SqlQueryStatement {
+    returning(returns) {
+        if (typeof returns === "function")
+            returns = returns();
+        let columnsStr;
+        if (returns === "*") {
+            columnsStr = "*";
+        }
+        else {
+            const res = selectColumnsOrTable(returns);
+            columnsStr = res.sqlColumns;
+        }
+        let sql = this.toString() + "\nRETURNING " + columnsStr;
+        return new SqlQueryStatement(sql);
+    }
+    onConflict(onConflict) {
+        if (typeof onConflict === "function")
+            onConflict = onConflict();
+        if (typeof onConflict !== "string")
+            onConflict = onConflict.join(",");
+        let sql = this.toString() + `\nON CONFLICT (${onConflict})`;
+        return new AfterInsert(sql);
+    }
+    where(where$1) {
+        const sql = where(where$1);
+        return new AfterUpdateOrReturn(this.toString() + sql);
+    }
+}
+class AfterInsert {
+    constructor(sql) {
+        _AfterInsert_sql.set(this, void 0);
+        __classPrivateFieldSet(this, _AfterInsert_sql, sql, "f");
+    }
+    doUpdate(set) {
+        if (typeof set === "function")
+            set = set();
+        let sql = this.toString();
+        if (typeof set === "object") {
+            sql += "\nDO UPDATE ";
+            sql += createUpdateSetFromObject(set);
+        }
+        else if (set)
+            sql += "DO UPDATE SET\n" + set;
+        else
+            sql += "DO NOTHING";
+        return new AfterUpdateOrReturn(sql);
+    }
+    doNotThing() {
+        return new AfterUpdateOrReturn(__classPrivateFieldGet(this, _AfterInsert_sql, "f") + " DO NOTHING");
+    }
+    toString() {
+        return __classPrivateFieldGet(this, _AfterInsert_sql, "f");
+    }
+}
+_AfterInsert_sql = new WeakMap();
+
+/**
+ * 数据库表
+ * @public
+ */
+class DbTable extends SqlSelectable {
+    constructor(name) {
+        super();
+        this.name = name;
     }
     fromAs(as) {
-        return new Selection(this, as);
+        return new Selection(this.name, as);
     }
     select(columns, as) {
         return this.fromAs(as).select(columns);
     }
-    insert(values, columns_option, option) {
+    /**
+     * INSERT 语句，需要注意 SQL 注入
+     * @example
+     * ```ts
+     * table.insert(["age","name"], "VALUES (18, 'hi'), (17, 'hh')") // INSERT INTO table(age,name) VALUES(18, 'hi'), (17, 'hh')
+     * ```
+     */
+    insert(columns, values) {
+        if (typeof columns !== "string" || !columns)
+            throw new TypeError("columns 必须是有效的 string 类型");
+        if (typeof values === "function")
+            values = values();
+        if (typeof values !== "string")
+            throw new TypeError("values 必须是 string 或 function 类型");
+        let sql = `INSERT INTO ${this.name}(${columns})\n${values}`;
+        return new AfterUpdateOrReturn(sql);
+    }
+    /**
+     * UPDATE 语句，需要注意 SQL 注入
+     * @example
+     * ```ts
+     * table.update("age=3, name='hi'") // "UPDATE table SET age=3, name='hi'"
+     * table.update({age: "3", name: "'hi'", k1: undefined, k2: ""}) // "UPDATE table SET age=3, name='hi'"
+     * ```
+     */
+    update(values) {
         if (typeof values === "function")
             values = values();
-        let columnStr;
-        let valuesStr;
-        if (typeof values === "string") {
-            valuesStr = values;
-            if (typeof columns_option === "string")
-                columnStr = columns_option;
-            else if (columns_option instanceof Array) {
-                if (columns_option.length === 0)
-                    throw new Error("插入列为空");
-                columnStr = columns_option.join(",");
+        switch (typeof values) {
+            case "object": {
+                let sql = createUpdateSetFromObject(values);
+                return new AfterUpdateOrReturn("UPDATE " + this.name + " " + sql);
             }
-            else
-                throw new Error("当 values 为 string 类型时，必须指定 columns");
+            case "string":
+                return new AfterUpdateOrReturn("UPDATE " + this.name + " SET\n" + values);
+            default:
+                throw new TypeError("参数 values 错误");
+        }
+    }
+    delete(option = {}) {
+        let sql = "DELETE FROM " + this.name;
+        sql += where(option.where);
+        return new AfterUpdateOrReturn(sql);
+    }
+    toSelect() {
+        return this.name;
+    }
+    toString() {
+        return this.name;
+    }
+}
+
+/** @public */
+class DbTableQuery extends DbTable {
+    constructor(name, statement) {
+        super(name);
+        this.statement = statement;
+    }
+    insert(values_column, _values) {
+        if (_values)
+            return super.insert(values_column, _values);
+        let values = values_column;
+        if (typeof values === "function")
+            values = values();
+        if (typeof values !== "object")
+            throw new TypeError("values 类型错误");
+        let valuesStr;
+        let insertCol;
+        if (values instanceof Array) {
+            if (values.length === 0)
+                throw new Error("值不能为空");
+            insertCol = Array.from(getObjectListKeys(values));
+            valuesStr = `VALUES\n${this.statement.objectListToValuesList(values, insertCol)}`;
         }
         else {
-            let insertCol;
-            option = columns_option;
-            if (typeof values === "object") {
-                if (values instanceof Array) {
-                    if (values.length === 0)
-                        throw new Error("值不能为空");
-                    insertCol = Array.from(getObjectListKeys(values));
-                    valuesStr = `VALUES\n${this.statement.objectListToValuesList(values, insertCol)}`;
-                }
-                else if (values instanceof SqlQueryStatement) {
-                    // todo 验证 values.columns 和 this.columns 是否匹配
-                    valuesStr = values.toString();
-                    insertCol = values.columns;
-                }
-                else {
-                    insertCol = Object.keys(values);
-                    valuesStr = `VALUES\n(${this.statement.objectToValues(values, insertCol)})`;
-                }
-            }
-            else
-                throw new Error("values 应该是 Array 或 TableQuery 类型");
-            if (insertCol.length === 0)
-                throw new Error("插入列不能为空");
-            columnStr = insertCol.join(",");
+            insertCol = Object.keys(values);
+            valuesStr = `VALUES\n(${this.statement.objectToValues(values, insertCol)})`;
         }
+        if (insertCol.length === 0)
+            throw new Error("插入列不能为空");
+        const columnStr = insertCol.join(",");
         let sql = `INSERT INTO ${this.name} (${columnStr})\n${valuesStr}`;
-        if (option) {
-            let { updateValues, conflict, where: inputWhere } = option;
-            if (conflict) {
-                if (typeof conflict !== "string")
-                    conflict = conflict.join(",");
-                sql += `\nON CONFLICT (${conflict})`;
-                if (typeof updateValues === "function")
-                    updateValues = updateValues();
-                if (updateValues) {
-                    const updateKey = Object.entries(updateValues);
-                    sql += `\nDO UPDATE SET\n${updateKey.map(([key, v = "EXCLUDED." + key]) => key + " = " + v).join(",\n")}`;
-                }
-                else
-                    sql += "DO NOTHING";
-                sql += where(inputWhere);
-            }
-        }
-        return sql;
-    }
-    insertWithResult(values, returns, columns, option) {
-        let sql = this.insert(values, columns, option);
-        return genRetuningSql(sql, returns);
+        return new AfterUpdateOrReturn(sql);
     }
     /**
+     * UPDATE 语句，与 update() 不同的是，它会将值进行安全转换
      * @example
      * ```ts
-     * table.update("age=3, name='hi'") // "UPDATE table SET age=3, name='hi'"
-     * table.update({age:3, name:"hi"}) // "UPDATE table SET age=3, name='hi'"
+     * table.update({age:3, name:"hi"}, true) // "UPDATE table SET age=3, name='hi'"
      * ```
      */
-    update(values, option = {}) {
+    updateFrom(values) {
         if (typeof values === "function")
             values = values();
         let setStr;
@@ -806,41 +920,15 @@ class DbTableQuery extends DbTable {
             for (const [k, v] of updateKey) {
                 if (v === undefined)
                     continue;
-                setList.push(k + " = " + this.statement.toSqlStr(v));
+                setList.push(k + "= " + this.statement.toSqlStr(v));
             }
             setStr = setList.join(",\n");
         }
         if (!setStr)
             throw new Error("值不能为空");
-        let sql = `UPDATE ${this.name}\nSET ${setStr}`;
-        sql += where(option.where);
-        return sql;
-    }
-    updateWithResult(values, returns, option) {
-        let sql = this.update(values, option);
-        return genRetuningSql(sql, returns);
-    }
-    delete(option = {}) {
-        let sql = "DELETE FROM " + this.name;
-        sql += where(option.where);
-        return sql;
-    }
-    deleteWithResult(returns = "*", option) {
-        let sql = this.delete(option);
-        return genRetuningSql(sql, returns);
-    }
-}
-function genRetuningSql(sql, returns) {
-    let columnsStr;
-    if (returns === "*") {
-        columnsStr = "*";
-    }
-    else {
-        const res = selectColumnsOrTable(returns);
-        columnsStr = res.sqlColumns;
+        let sql = `UPDATE ${this.name} SET\n${setStr}`;
+        return new AfterUpdateOrReturn(sql);
     }
-    sql += "\nRETURNING " + columnsStr;
-    return new SqlQueryStatement(sql);
 }
 
 /**

package/dist/select/DbTable.d.ts

@@ -0,0 +1,47 @@
+import { SqlSelectable } from "./selectable.ts";
+import { ConditionParam, Constructable, SelectParam } from "../util.ts";
+import type { TableType } from "./type.ts";
+import { CurrentModifyWhere, CurrentOnConflict, CurrentWhere, Selection } from "./query_link.ts";
+/**
+ * 数据库表
+ * @public
+ */
+export declare class DbTable<T extends TableType> extends SqlSelectable<T> {
+    readonly name: string;
+    constructor(name: string);
+    fromAs(as?: string): Selection;
+    /** 选择单表全部列 */
+    select(columns: "*", as?: string): CurrentWhere<T>;
+    /** 选择单表  */
+    select<R extends {}>(columns: Constructable<{
+        [key in keyof R]: boolean | string;
+    } | string>, as?: string): CurrentWhere<R>;
+    select<R extends {}>(columns: Constructable<SelectParam>): CurrentWhere<R>;
+    /**
+     * INSERT 语句，需要注意 SQL 注入
+     * @example
+     * ```ts
+     * table.insert(["age","name"], "VALUES (18, 'hi'), (17, 'hh')") // INSERT INTO table(age,name) VALUES(18, 'hi'), (17, 'hh')
+     * ```
+     */
+    insert(columns: string, values: Constructable<string>): CurrentOnConflict<T>;
+    /**
+     * UPDATE 语句，需要注意 SQL 注入
+     * @example
+     * ```ts
+     * table.update("age=3, name='hi'") // "UPDATE table SET age=3, name='hi'"
+     * table.update({age: "3", name: "'hi'", k1: undefined, k2: ""}) // "UPDATE table SET age=3, name='hi'"
+     * ```
+     */
+    update(values: Constructable<{
+        [key in keyof T]?: string;
+    } | string>): CurrentModifyWhere<T>;
+    delete(option?: DeleteOption): CurrentModifyWhere<T>;
+    toSelect(): string;
+    toString(): string;
+}
+/** @public */
+export interface DeleteOption {
+    where?: Constructable<ConditionParam | void>;
+}
+//# sourceMappingURL=DbTable.d.ts.map

package/dist/select/TableQuery.d.ts

@@ -1,28 +1,12 @@
 import { SqlValuesCreator } from "../sql_value/sql_value.ts";
-import { ColumnsSelected, SelectColumns, UpdateRowValue, TableType } from "./type.ts";
-import { CurrentWhere, Selection } from "./select.ts";
-import { DbTable, SqlQueryStatement } from "./selectable.ts";
-import { ConditionParam, Constructable } from "../util.ts";
+import { UpdateRowValue, TableType } from "./type.ts";
+import { Constructable } from "../util.ts";
+import { DbTable } from "./DbTable.ts";
+import type { CurrentModifyWhere, CurrentOnConflict } from "./query_link.ts";
 /** @public */
 export declare class DbTableQuery<T extends TableType = Record<string, any>, C extends TableType = Partial<T>> extends DbTable<T> {
     private statement;
     constructor(name: string, statement: SqlValuesCreator);
-    fromAs(as?: string): Selection;
-    /** 选择单表全部列 */
-    select(columns: "*", as?: string): CurrentWhere<T>;
-    /**
-     * 选择单表
-     * @param columns - 对象选择
-     */
-    select<R extends {
-        [key in keyof T]?: boolean;
-    }>(columns: Constructable<R>, as?: string): CurrentWhere<{
-        [key in keyof R]: key extends keyof T ? T[key] : unknown;
-    }>;
-    /** 选择单表- 所有类型 */
-    select<R extends {}>(columns: Constructable<{
-        [key in keyof R]?: key extends keyof T ? string | boolean : string;
-    } | string>, as?: string): CurrentWhere<R>;
     /**
      * @example
      * ```ts
@@ -30,42 +14,15 @@ export declare class DbTableQuery<T extends TableType = Record<string, any>, C e
      * table.insert([{age:18, name:"hi"}, {age:17, name:"hh"}]) // INSERT INTO table(age,name) VALUES(18, 'hi'), (17, 'hh')
      * ```
      */
-    insert(values: Constructable<C | C[]>, option?: InsertOption<T>): string;
-    /**
-     * @example
-     * ```ts
-     * table.insert("VALUES (18, 'hi'), (17, 'hh')", ["age","name"]) // INSERT INTO table(age,name) VALUES(18, 'hi'), (17, 'hh')
-     * ```
-     */
-    insert(values: Constructable<string>, columns: string[], option?: InsertOption<T>): string;
-    insertWithResult<R extends ColumnsSelected<T>>(values: Constructable<C | C[]>, returns: R, option?: InsertOption<T>): SqlQueryStatement<SelectColumns<T, R>>;
-    insertWithResult<R extends ColumnsSelected<T>>(values: Constructable<string>, returns: R, columns: string | string[], option?: InsertOption<T>): SqlQueryStatement<SelectColumns<T, R>>;
+    insert(values: Constructable<UpdateRowValue<C> | UpdateRowValue<C>[]>): CurrentOnConflict<T>;
+    insert(columns: string, values: Constructable<string>): CurrentOnConflict<T>;
     /**
+     * UPDATE 语句，与 update() 不同的是，它会将值进行安全转换
      * @example
      * ```ts
-     * table.update("age=3, name='hi'") // "UPDATE table SET age=3, name='hi'"
-     * table.update({age:3, name:"hi"}) // "UPDATE table SET age=3, name='hi'"
+     * table.update({age:3, name:"hi"}, true) // "UPDATE table SET age=3, name='hi'"
      * ```
      */
-    update(values: Constructable<UpdateRowValue<T> | string>, option?: UpdateOption): string;
-    updateWithResult<R extends ColumnsSelected<T>>(values: Constructable<UpdateRowValue<T>>, returns: R, option?: UpdateOption): SqlQueryStatement<SelectColumns<T, R>>;
-    delete(option?: DeleteOption): string;
-    deleteWithResult<R extends ColumnsSelected<T>>(returns?: ColumnsSelected<T> | "*", option?: DeleteOption): SqlQueryStatement<SelectColumns<T, R>>;
-}
-/** @public */
-export interface InsertOption<T extends object> {
-    conflict?: (keyof T)[] | string;
-    updateValues?: Constructable<{
-        [key in keyof T]?: undefined | String | T[key];
-    } | string | void>;
-    where?: Constructable<ConditionParam | void>;
-}
-/** @public */
-export interface UpdateOption {
-    where?: Constructable<ConditionParam | void>;
-}
-/** @public */
-export interface DeleteOption {
-    where?: Constructable<ConditionParam | void>;
+    updateFrom(values: Constructable<UpdateRowValue<T>>): CurrentModifyWhere<T>;
 }
 //# sourceMappingURL=TableQuery.d.ts.map

package/dist/select/_statement.d.ts

@@ -8,5 +8,6 @@ type ConditionParam = string | string[];
  * 生成条件语句
  */
 export declare function condition(conditions?: Constructable<ConditionParam | void>, type?: "AND" | "OR"): string;
+export declare function createUpdateSetFromObject(set: Record<string, string | undefined>): string;
 export {};
 //# sourceMappingURL=_statement.d.ts.map

package/dist/select/_update_impl.d.ts

@@ -0,0 +1,19 @@
+import { ConditionParam, Constructable } from "../util.ts";
+import { CurrentModifyWhere, CurrentOnConflict, CurrentOnConflictDo, CurrentReturn } from "./query_link.ts";
+import { SqlQueryStatement } from "./selectable.ts";
+import { ColumnsSelected, TableType } from "./type.ts";
+export declare class AfterUpdateOrReturn<T extends TableType = {}> extends SqlQueryStatement<{}> implements CurrentOnConflict<T>, CurrentModifyWhere<T> {
+    returning<R extends {}>(returns: Constructable<ColumnsSelected<any> | "*">): SqlQueryStatement<R>;
+    onConflict(onConflict: Constructable<readonly string[] | string>): CurrentOnConflictDo<T>;
+    where(where: Constructable<ConditionParam | void>): CurrentReturn<T>;
+}
+export declare class AfterInsert<T extends TableType = {}> implements CurrentOnConflictDo<T> {
+    #private;
+    constructor(sql: string);
+    doUpdate(set?: Constructable<string | {
+        [key: string]: string | undefined;
+    }>): CurrentModifyWhere<T>;
+    doNotThing(): CurrentReturn<T>;
+    toString(): string;
+}
+//# sourceMappingURL=_update_impl.d.ts.map

package/dist/select/{select.d.ts → query_link.d.ts}

@@ -1,9 +1,9 @@
 import { SqlSelectable, SqlQueryStatement } from "./selectable.ts";
 import { OrderByParam, ConditionParam, SelectParam, Constructable } from "../util.ts";
-import type { TableType } from "./type.ts";
+import type { ColumnsSelected, SelectColumns, TableType } from "./type.ts";
 /** @public */
 export interface CurrentLimit<T extends TableType> extends SqlQueryStatement<T> {
-    limit(limit?: number, offset?: number): SqlQueryStatement<T>;
+    limit(limit?: number | bigint, offset?: number | bigint): SqlQueryStatement<T>;
 }
 /** @public */
 export interface CurrentOrderBy<T extends TableType> extends CurrentLimit<T> {
@@ -54,6 +54,31 @@ export declare class Selection {
     select<T extends TableType>(columns: Constructable<{
         [key in keyof T]: string | boolean;
     }>): CurrentWhere<T>;
-    select(columns: Constructable<SelectParam>): CurrentWhere<TableType>;
+    select<R extends {}>(columns: Constructable<SelectParam>): CurrentWhere<R>;
 }
-//# sourceMappingURL=select.d.ts.map
+/** @public */
+export interface CurrentReturn<T extends TableType = {}> extends SqlQueryStatement<{}> {
+    returning(columns: "*"): SqlQueryStatement<T>;
+    returning<R extends ColumnsSelected<T>>(columns: Constructable<R>): SqlQueryStatement<SelectColumns<T, R>>;
+    returning<R extends TableType>(columns: Constructable<R | string>): SqlQueryStatement<T>;
+}
+/** @public */
+export type CurrentModifyWhere<T extends TableType = {}> = CurrentReturn<T> & {
+    where(where: Constructable<ConditionParam | void>): CurrentReturn<T>;
+};
+/** @public */
+export type CurrentOnConflictDo<T extends TableType = {}> = {
+    doNotThing(): CurrentReturn<T>;
+    /**
+     * 需要注意 SQL 注入
+     */
+    doUpdate(set: Constructable<{
+        [key in keyof T]?: string;
+    }>): CurrentModifyWhere<T>;
+    toString(): string;
+};
+/** @public */
+export type CurrentOnConflict<T extends TableType = {}> = CurrentReturn<T> & {
+    onConflict(option: Constructable<readonly (keyof T)[] | string>): CurrentOnConflictDo<T>;
+};
+//# sourceMappingURL=query_link.d.ts.map

package/dist/select/selectable.d.ts

@@ -22,16 +22,6 @@ export declare abstract class SqlSelectable<T extends TableType> {
     /** 保留以推断类型 */
     protected [SQL_SELECTABLE]: T;
 }
-/**
- * 数据库表
- * @public
- */
-export declare class DbTable<T extends TableType> extends SqlSelectable<T> {
-    readonly name: string;
-    constructor(name: string);
-    toSelect(): string;
-    toString(): string;
-}
 /**
  * SELECT 以及 UPDATE、DELETE、INSERT INTO 带结果的 SQL 语句
  * @public

package/dist/select/type.d.ts

@@ -26,12 +26,12 @@ export type OrderValue = "ASC" | "DESC";
  */
 export type ColumnsSelected<T extends TableType> = {
     [key in keyof T]?: boolean | string;
-} | "*";
+};
 /**
  * 从一个表格选择列，生成新的表格类型
  * @public
  */
-export type SelectColumns<T extends TableType, R extends ColumnsSelected<T>> = R extends "*" ? T : R extends {
+export type SelectColumns<T extends TableType, R extends ColumnsSelected<T>> = R extends {
     [key in keyof T]?: boolean | string;
 } ? {
     [key in keyof T as R[key] extends true ? key : StringOnly<R[key]>]: T[key];

package/dist/sql_value/sql_value.d.ts

@@ -14,11 +14,6 @@ export type JsObjectMapSql = Map<new (...args: any[]) => any, SqlValueEncoder>;
 export type SqlValueEncoder<T = any> = (this: SqlValuesCreator, value: T) => string;
 /** @public 断言类型 */
 export type AssertJsType = "bigint" | "number" | "string" | "boolean" | "object" | (new (...args: any[]) => any);
-/**
- * @deprecated 改用 AssertJsType
- * @public 断言类型
- */
-export type ManualType = AssertJsType;
 /** @public */
 export type SqlValueFn = SqlValuesCreator & {
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asla/yoursql",
-  "version": "0.6.5",
+  "version": "0.7.0",
   "description": "",
   "type": "module",
   "types": "./dist/mod.d.ts",