@asla/yoursql 0.8.0 → 0.8.2

package/dist/client/DbCursor.d.ts

@@ -0,0 +1,14 @@
+/** @public */
+export interface DbCursorOption {
+    defaultSize?: number;
+}
+/** @public */
+export declare abstract class DbCursor<T> {
+    /** 读取游标，如果读取结束，返回空数组 */
+    abstract read(maxSize?: number): Promise<T[]>;
+    /** 提前关闭游标，如果多次调用，会被忽略 */
+    abstract close(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+    [Symbol.asyncIterator](): AsyncGenerator<T, undefined, void>;
+}
+//# sourceMappingURL=DbCursor.d.ts.map

package/dist/client/DbPoolConnection.d.ts

@@ -0,0 +1,29 @@
+import type { SqlStatementDataset } from "../sql_gen/mod.ts";
+import { DbQuery } from "./DbQuery.ts";
+import type { MultipleQueryResult, QueryRowsResult } from "./DbQuery.ts";
+import type { DbConnection, TransactionMode } from "./interfaces.ts";
+/**
+
+/**
+ * 池连接
+ * @public
+ */
+export declare class DbPoolConnection extends DbQuery {
+    #private;
+    constructor(conn: DbConnection, onRelease: () => void);
+    begin(mode?: TransactionMode): Promise<void>;
+    query<T = any>(sql: SqlStatementDataset<T>): Promise<QueryRowsResult<T>>;
+    query<T = any>(sql: {
+        toString(): string;
+    }): Promise<QueryRowsResult<T>>;
+    multipleQuery<T extends MultipleQueryResult = MultipleQueryResult>(sql: {
+        toString(): string;
+    }): Promise<T>;
+    rollback(): Promise<void>;
+    commit(): Promise<void>;
+    get released(): boolean;
+    /** 调用 release() 时，如果事务未提交，则抛出异常 */
+    release(): void;
+    [Symbol.dispose](): void;
+}
+//# sourceMappingURL=DbPoolConnection.d.ts.map

package/dist/client/DbPoolTransaction.d.ts

@@ -0,0 +1,29 @@
+import type { SqlStatementDataset } from "../sql_gen/mod.ts";
+import { DbQuery } from "./DbQuery.ts";
+import type { MultipleQueryResult, QueryRowsResult } from "./DbQuery.ts";
+import type { DbPoolConnection } from "./DbPoolConnection.ts";
+import type { DbTransaction, TransactionMode } from "./interfaces.ts";
+/**
+ * @public
+ * 池连接事务
+ */
+export declare class DbPoolTransaction extends DbQuery implements DbTransaction {
+    #private;
+    readonly mode?: TransactionMode | undefined;
+    constructor(connect: () => Promise<DbPoolConnection>, mode?: TransactionMode | undefined);
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    savePoint(savePoint: string): Promise<void>;
+    rollbackTo(savePoint: string): Promise<void>;
+    query<T extends object = any>(sql: SqlStatementDataset<T>): Promise<QueryRowsResult<T>>;
+    query<T extends object = any>(sql: {
+        toString(): string;
+    }): Promise<QueryRowsResult<T>>;
+    multipleQuery<T extends MultipleQueryResult = MultipleQueryResult>(sql: SqlStatementDataset<T>): Promise<T>;
+    multipleQuery<T extends MultipleQueryResult = MultipleQueryResult>(sql: {
+        toString(): string;
+    }): Promise<T>;
+    get released(): boolean;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+//# sourceMappingURL=DbPoolTransaction.d.ts.map

package/dist/client/DbQuery.d.ts

@@ -0,0 +1,68 @@
+import type { SqlStatementDataset } from "../sql_gen/mod.ts";
+/** @public */
+export interface SingleQueryResult {
+    rowCount: number;
+    rows?: any[];
+}
+/** @public */
+export interface QueryRowsResult<T = any> extends SingleQueryResult {
+    rowCount: number;
+    rows: T[];
+}
+/** @public */
+export type MultipleQueryResult = SingleQueryResult[];
+/** @public */
+export type QueryResult = MultipleQueryResult | SingleQueryResult;
+/**
+ * SQL 查询相关操作
+ * @public
+ */
+export declare abstract class DbQuery {
+    /** 单语句查询，不应查询条语句，否则返回错误值  */
+    abstract query<T = any>(sql: SqlStatementDataset<T>): Promise<QueryRowsResult<T>>;
+    /** 单语句查询，不应查询条语句，否则返回错误值  */
+    abstract query<T = any>(sql: {
+        toString(): string;
+    }): Promise<QueryRowsResult<T>>;
+    /** 多语句查询  */
+    abstract multipleQuery<T extends MultipleQueryResult = MultipleQueryResult>(sql: SqlStatementDataset<T>): Promise<T>;
+    /** 多语句查询 */
+    abstract multipleQuery<T extends MultipleQueryResult = MultipleQueryResult>(sql: {
+        toString(): string;
+    }): Promise<T>;
+    /** 单语句查询受影响的行 */
+    queryCount(sql: string | {
+        toString(): string;
+    }): Promise<number>;
+    /** 单语句查询，不应查询条语句，否则返回错误值  */
+    queryRows<T = any>(sql: SqlStatementDataset<T>): Promise<T[]>;
+    /** 单语句查询，不应查询条语句，否则返回错误值  */
+    queryRows<T = any>(sql: {
+        toString(): string;
+    }): Promise<T[]>;
+    /**
+     * 查询行
+     * 不应查询单条语句，否则返回错误值
+     */
+    multipleQueryRows<T extends any[] = any[]>(sql: SqlStatementDataset<T>): Promise<T[]>;
+    /**
+     * 查询行
+     * 不应查询条语句，否则返回错误值
+     */
+    multipleQueryRows<T extends any[] = any[]>(sql: {
+        toString(): string;
+    }): Promise<T[]>;
+    /**
+     * 指定某一列为key，返回 key 到 row 的映射
+     * 单语句查询，不应查询条语句，否则返回错误值
+     */
+    queryMap<T extends Record<string, any> = Record<string, any>, K extends keyof T = string>(sql: SqlStatementDataset<T>, key: K): Promise<Map<T[K], T>>;
+    /**
+     * 指定某一列为key，返回 key 到 row 的映射
+     * 单语句查询，不应查询条语句，否则返回错误值
+     */
+    queryMap<T extends Record<string, any> = Record<string, any>, K extends keyof T = string>(sql: {
+        toString(): string;
+    }, key: K): Promise<Map<T[K], T>>;
+}
+//# sourceMappingURL=DbQuery.d.ts.map

package/dist/client/errors.d.ts

@@ -0,0 +1,9 @@
+/** @public */
+export declare class ParallelQueryError extends Error {
+    constructor();
+}
+/** @public */
+export declare class ConnectionNotAvailableError extends Error {
+    constructor(message: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/client/interfaces.d.ts

@@ -0,0 +1,66 @@
+import type { SqlStatementDataset } from "../sql_gen/mod.ts";
+import { DbQuery } from "./DbQuery.ts";
+import { DbPoolConnection } from "./DbPoolConnection.ts";
+import { DbCursor, DbCursorOption } from "./DbCursor.ts";
+/**
+ * 数据库连接
+ * @public
+ */
+export interface DbConnection extends DbQuery, AsyncDisposable {
+    close(): Promise<void>;
+}
+/** @public */
+export type TransactionMode = "SERIALIZABLE" | "REPEATABLE READ" | "READ COMMITTED" | "READ UNCOMMITTED";
+/**
+ * SQL 事务查询操作
+ *
+ * 使用 `await using` 语法离开作用域时，如果没有 `commit()` 或 `rollback(`) , 则调用 `rollback()`
+ *
+ * ```ts
+ * async function doSomeTransaction(){
+ *    await using transaction = pool.begin()
+ *    await transaction.query("SELECT * FROM user")
+ *    throw new Error("error")
+ * }
+ * try{
+ *    await doSomeTransaction()
+ * }catch(e){
+ *    console.error(e)
+ * }
+ * ```
+ * 下面的写法会造成连接池泄露
+ * ```ts
+ * async function doSomeTransaction(){
+ *    const transaction = pool.begin()
+ *    await transaction.query("SELECT * FROM user")
+ * }
+ * await doSomeTransaction() // 离开作用域后连接不会被回收
+ * console.warn("连接未被回收！")
+ *
+ * ```
+ * @public
+ */
+export interface DbTransaction extends DbQuery, AsyncDisposable {
+    /** 回滚，并释放连接 */
+    rollback(): Promise<void>;
+    /** 回滚到保存点 */
+    rollbackTo(savePoint: string): Promise<void>;
+    savePoint(savePoint: string): Promise<void>;
+    /** 提交，并释放连接 */
+    commit(): Promise<void>;
+}
+/**
+ * @public
+ * 池链接查询
+ */
+export interface DbQueryPool extends DbQuery {
+    connect(): Promise<DbPoolConnection>;
+    idleCount: number;
+    totalCount: number;
+    begin(mode?: TransactionMode): DbTransaction;
+    cursor<T extends {}>(sql: SqlStatementDataset<T>): Promise<DbCursor<T>>;
+    cursor<T>(sql: {
+        toString(): string;
+    }, option?: DbCursorOption): Promise<DbCursor<T>>;
+}
+//# sourceMappingURL=interfaces.d.ts.map

package/dist/client/mod.d.ts

@@ -0,0 +1,7 @@
+export * from "./errors.ts";
+export * from "./interfaces.ts";
+export * from "./DbQuery.ts";
+export * from "./DbCursor.ts";
+export * from "./DbPoolConnection.ts";
+export * from "./DbPoolTransaction.ts";
+//# sourceMappingURL=mod.d.ts.map

package/dist/client.js

@@ -0,0 +1,209 @@
+/** @public */
+class ParallelQueryError extends Error {
+    constructor() {
+        super("The previous query was not completed and cannot be executed");
+    }
+}
+/** @public */
+class ConnectionNotAvailableError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+
+/**
+ * SQL 查询相关操作
+ * @public
+ */
+class DbQuery {
+    /** 单语句查询受影响的行 */
+    queryCount(sql) {
+        return this.query(sql.toString()).then((res) => {
+            if (res.rowCount === null)
+                return 0;
+            return res.rowCount;
+        });
+    }
+    queryRows(sql) {
+        return this.query(sql.toString()).then((res) => res.rows);
+    }
+    multipleQueryRows(sql) {
+        return this.multipleQuery(sql.toString()).then((res) => res.map((item) => item.rows ?? []));
+    }
+    async queryMap(sql, key) {
+        const { rows } = await this.query(sql.toString());
+        let map = new Map();
+        for (let i = 0; i < rows.length; i++) {
+            map.set(rows[i][key], rows[i]);
+        }
+        return map;
+    }
+}
+
+/** @public */
+class DbCursor {
+    // implement
+    [Symbol.asyncDispose]() {
+        return this.close();
+    }
+    async *[Symbol.asyncIterator]() {
+        let data = await this.read();
+        try {
+            while (data.length) {
+                yield* data;
+                data = await this.read();
+            }
+        }
+        finally {
+            await this.close();
+        }
+    }
+}
+
+/**
+
+/**
+ * 池连接
+ * @public
+ */
+class DbPoolConnection extends DbQuery {
+    constructor(conn, onRelease) {
+        super();
+        this.#conn = conn;
+        this.#onRelease = onRelease;
+    }
+    #onRelease;
+    //implement
+    async begin(mode) {
+        await this.query("BEGIN" + (mode ? " TRANSACTION ISOLATION LEVEL " + mode : ""));
+    }
+    #conn;
+    query(sql) {
+        if (!this.#conn)
+            return Promise.reject(new ConnectionNotAvailableError("Connection already release"));
+        return this.#conn.query(sql);
+    }
+    multipleQuery(sql) {
+        if (!this.#conn)
+            return Promise.reject(new ConnectionNotAvailableError("Connection already release"));
+        return this.#conn.multipleQuery(sql);
+    }
+    //implement
+    async rollback() {
+        await this.query("ROLLBACK");
+    }
+    //implement
+    async commit() {
+        await this.query("COMMIT");
+    }
+    get released() {
+        return !this.#conn;
+    }
+    /** 调用 release() 时，如果事务未提交，则抛出异常 */
+    release() {
+        if (this.#conn) {
+            this.#conn = undefined;
+            this.#onRelease();
+        }
+    }
+    //implement
+    [Symbol.dispose]() {
+        return this.release();
+    }
+}
+
+/**
+ * @public
+ * 池连接事务
+ */
+class DbPoolTransaction extends DbQuery {
+    mode;
+    constructor(connect, mode) {
+        super();
+        this.mode = mode;
+        this.#query = (sql) => {
+            return new Promise((resolve, reject) => {
+                this.#pending = connect()
+                    .then((conn) => {
+                    this.#conn = conn;
+                    const promise = conn.multipleQuery("BEGIN" + (this.mode ? " TRANSACTION ISOLATION LEVEL " + this.mode : "") + ";\n" + sql);
+                    this.#pending = promise;
+                    this.#query = this.#queryAfter;
+                    return promise;
+                })
+                    .then((res) => {
+                    this.#pending = undefined;
+                    resolve(res[1]);
+                }, (e) => {
+                    this.#pending = undefined;
+                    reject(e);
+                    if (this.#conn)
+                        this.#release(this.#conn, e);
+                });
+            });
+        };
+    }
+    #pending;
+    #conn;
+    async commit() {
+        if (this.#pending)
+            throw new ParallelQueryError();
+        if (this.#conn) {
+            const promise = this.#conn.query("COMMIT");
+            this.#release(this.#conn);
+            await promise;
+        }
+    }
+    async rollback() {
+        if (this.#pending)
+            throw new ParallelQueryError();
+        if (this.#conn) {
+            const promise = this.#conn.query("ROLLBACK");
+            this.#release(this.#conn);
+            await promise;
+        }
+    }
+    savePoint(savePoint) {
+        return this.query("SAVEPOINT" + savePoint).then(() => { });
+    }
+    rollbackTo(savePoint) {
+        return this.query("ROLLBACK TO " + savePoint).then(() => { });
+    }
+    /** 拿到连接后执行这个 */
+    #queryAfter(sql) {
+        return this.#conn.query(sql).then((res) => {
+            this.#pending = undefined;
+            return res;
+        }, (e) => {
+            this.#pending = undefined;
+            this.#release(this.#conn, e);
+            throw e;
+        });
+    }
+    #query;
+    query(sql) {
+        if (this.#pending)
+            return Promise.reject(new ParallelQueryError());
+        return this.#query(sql.toString());
+    }
+    multipleQuery(sql) {
+        if (this.#pending)
+            return Promise.reject(new ParallelQueryError());
+        return this.#query(sql.toString());
+    }
+    #error;
+    #release(conn, error = new ConnectionNotAvailableError("Connection already release")) {
+        this.#error = error;
+        this.#query = () => Promise.reject(this.#error);
+        this.#conn = undefined;
+        conn.release();
+    }
+    get released() {
+        return !!this.#error;
+    }
+    [Symbol.asyncDispose]() {
+        return this.rollback();
+    }
+}
+
+export { ConnectionNotAvailableError, DbCursor, DbPoolConnection, DbPoolTransaction, DbQuery, ParallelQueryError };

package/dist/{select → sql_gen/select}/_statement.d.ts

@@ -1,8 +1,4 @@
 import { Constructable } from "../util.ts";
-export declare function selectColumnsOrTable(columns: Record<string, boolean | string> | string[]): {
-    columns: string[];
-    sqlColumns: string;
-};
 type ConditionParam = string | string[];
 /**
  * 生成条件语句

package/dist/{select → sql_gen/select}/query_chain_abstract.d.ts

@@ -1,5 +1,5 @@
-import { ConditionParam, Constructable, OrderByParam } from "../util.ts";
-import { ColumnsSelected, TableType } from "./type.ts";
+import { ConditionParam, Constructable, OrderByParam, SelectParam } from "../util.ts";
+import { TableType } from "./type.ts";
 /** @public */
 export declare abstract class SqlStatement {
     /** 获取 SQL 语句 */
@@ -55,8 +55,8 @@ export interface ChainSelectWhere<T extends TableType> extends ChainSelectGroupB
 /** @public */
 export interface ChainModifyReturning<T extends TableType = {}> extends SqlStatement {
     returning(columns: "*"): SqlStatementDataset<T>;
-    returning(columns: Constructable<ColumnsSelected<T> | string>): SqlStatementDataset<Record<string, any>>;
-    returning<R extends TableType>(columns: Constructable<ColumnsSelected<R> | string>): SqlStatementDataset<R>;
+    returning(columns: Constructable<SelectParam>): SqlStatementDataset<Record<string, any>>;
+    returning<R extends TableType>(columns: Constructable<SelectParam>): SqlStatementDataset<R>;
 }
 /** @public */
 export interface ChainModifyWhere<T extends TableType = {}> extends ChainModifyReturning<T> {

package/dist/{select → sql_gen/select}/query_chain_insert.d.ts

@@ -1,10 +1,10 @@
-import { ConditionParam, Constructable } from "../util.ts";
+import { ConditionParam, Constructable, SelectParam } from "../util.ts";
 import { SqlStatementDataset, SqlStatement, ChainModifyWhere, ChainOnConflict, ChainConflictDo, ChainModifyReturning } from "./query_chain_abstract.ts";
-import { ColumnsSelected, TableType } from "./type.ts";
+import { TableType } from "./type.ts";
 export declare class SqlChainModify<T extends TableType = {}> extends SqlStatement implements ChainOnConflict<T>, ChainModifyWhere<T> {
     readonly sql: string;
     constructor(sql: string);
-    returning<R extends {}>(returns: Constructable<ColumnsSelected<any> | "*">): SqlStatementDataset<R>;
+    returning<R extends {}>(returns: Constructable<SelectParam | "*">): SqlStatementDataset<R>;
     onConflict(onConflict: Constructable<readonly string[] | string>): ChainConflictDo<T>;
     where(where: Constructable<ConditionParam | void>): ChainModifyReturning<T>;
     toString(): string;

package/dist/{select → sql_gen/select}/type.d.ts

@@ -20,26 +20,8 @@ export type UpdateRowValue<T extends object> = {
 };
 /** @public */
 export type OrderValue = "ASC" | "DESC";
-/**
- * 表的选择参数
- * @public
- */
-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 {
-    [key in keyof T]?: boolean | string;
-} ? {
-    [key in keyof T as R[key] extends true ? key : StringOnly<R[key]>]: T[key];
-} : never;
-type StringOnly<T> = T extends string ? T : never;
 /** @public */
 export type TableType = {
     [key: string]: any;
 };
-export {};
 //# sourceMappingURL=type.d.ts.map

package/dist/{util.d.ts → sql_gen/util.d.ts}

@@ -30,7 +30,7 @@ export declare function where(conditions?: Constructable<ConditionParam | void>,
  */
 export declare function having(conditions?: Constructable<ConditionParam | void>, type?: "AND" | "OR"): string;
 /** @public */
-export type SelectParam = string | Record<string, string | boolean>;
+export type SelectParam = string | string[] | Record<string, string | boolean>;
 /**
  * @public
  * @example

package/dist/{mod.js → sql_gen.js}

@@ -1,65 +1,3 @@
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-
-function __classPrivateFieldGet(receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-}
-
-function __classPrivateFieldSet(receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
-function selectColumnsOrTable(columns) {
-    let sqlSelect;
-    let select;
-    if (columns instanceof Array) {
-        sqlSelect = columns;
-        select = columns;
-    }
-    else {
-        sqlSelect = [];
-        select = [];
-        let c;
-        for (const key of Object.keys(columns)) {
-            c = columns[key];
-            if (typeof c === "string" && c !== key) {
-                sqlSelect.push(key + " AS " + c);
-                select.push(c);
-            }
-            else if (c) {
-                sqlSelect.push(key);
-                select.push(key);
-            }
-        }
-    }
-    if (select.length === 0)
-        throw new Error("选择列为空");
-    return { columns: select, sqlColumns: sqlSelect.join(", ") };
-}
 function condition(conditions, type = "AND") {
     if (typeof conditions === "function")
         conditions = conditions();
@@ -186,26 +124,33 @@ function selectColumns(columns) {
         case "string":
             return columns;
         case "object": {
-            let sql = "";
-            const keys = Object.keys(columns);
-            if (keys.length === 0)
-                throw new Error("没有选择任何列");
-            let k = keys[0];
-            let v = columns[k];
-            if (typeof v === "string")
-                sql += v + " AS " + k;
-            else
-                sql += k;
-            for (let i = 1; i < keys.length; i++) {
-                k = keys[i];
-                v = columns[k];
-                sql += ",";
+            if (columns instanceof Array) {
+                if (columns.length === 0)
+                    throw new Error("没有选择任何列");
+                return columns.join(",");
+            }
+            else {
+                let sql = "";
+                const keys = Object.keys(columns);
+                if (keys.length === 0)
+                    throw new Error("没有选择任何列");
+                let k = keys[0];
+                let v = columns[k];
                 if (typeof v === "string")
                     sql += v + " AS " + k;
                 else
                     sql += k;
+                for (let i = 1; i < keys.length; i++) {
+                    k = keys[i];
+                    v = columns[k];
+                    sql += ",";
+                    if (typeof v === "string")
+                        sql += v + " AS " + k;
+                    else
+                        sql += k;
+                }
+                return sql;
             }
-            return sql;
         }
         default:
             throw new TypeError("columns 应为 string 或 object 类型");
@@ -291,6 +236,7 @@ class SqlStatementDataset extends SqlStatement {
 }
 /** @public */
 class SqlTextStatementDataset extends SqlStatementDataset {
+    sql;
     constructor(sql) {
         super();
         this.sql = sql;
@@ -300,7 +246,6 @@ class SqlTextStatementDataset extends SqlStatementDataset {
     }
 }
 
-var _YourValuesAs_asName, _YourValuesAs_valuesStr, _YourValuesAs_sql;
 /**
  * SQL 原始字符类。可以使用 String 类代替，这只是为了推断类型
  * @public
@@ -346,6 +291,7 @@ class SqlValuesCreator {
             }
         }
     }
+    _map;
     /**
      * 将 JS 对象转为 SQL 的字符值的形式 。 undefined 将被转换为 DEFAULT
      * ```ts
@@ -564,21 +510,20 @@ class SqlValuesCreator {
 class YourValuesAs extends SqlStatementDataset {
     constructor(columns, asName, valuesStr) {
         super();
-        _YourValuesAs_asName.set(this, void 0);
-        _YourValuesAs_valuesStr.set(this, void 0);
-        _YourValuesAs_sql.set(this, void 0);
-        __classPrivateFieldSet(this, _YourValuesAs_asName, asName, "f");
-        __classPrivateFieldSet(this, _YourValuesAs_valuesStr, valuesStr, "f");
-        __classPrivateFieldSet(this, _YourValuesAs_sql, `(VALUES\n${__classPrivateFieldGet(this, _YourValuesAs_valuesStr, "f")})\nAS ${__classPrivateFieldGet(this, _YourValuesAs_asName, "f")}(${columns.join(",")})`, "f");
+        this.#asName = asName;
+        this.#valuesStr = valuesStr;
+        this.#sql = `(VALUES\n${this.#valuesStr})\nAS ${this.#asName}(${columns.join(",")})`;
     }
+    #asName;
+    #valuesStr;
+    #sql;
     toSelect() {
-        return __classPrivateFieldGet(this, _YourValuesAs_sql, "f");
+        return this.#sql;
     }
     toString() {
-        return __classPrivateFieldGet(this, _YourValuesAs_sql, "f");
+        return this.#sql;
     }
 }
-_YourValuesAs_asName = new WeakMap(), _YourValuesAs_valuesStr = new WeakMap(), _YourValuesAs_sql = new WeakMap();
 function initColumnAssert(keys, keys_types) {
     let key;
     let value;
@@ -638,7 +583,7 @@ const pgSqlTransformer = new Map([
     ],
 ]);
 
-var _Selection_instances, _a, _Selection_sql, _Selection_join;
+var _a;
 /**
  * @public ChainSelectWhere 的默认实现
  */
@@ -693,34 +638,40 @@ class Selection {
     static from(selectable, as) {
         return new this(selectable, as);
     }
+    #sql;
     constructor(selectable, as) {
-        _Selection_instances.add(this);
-        _Selection_sql.set(this, void 0);
-        __classPrivateFieldSet(this, _Selection_sql, fromAs(selectable, as), "f");
+        this.#sql = fromAs(selectable, as);
     }
     toString() {
-        return "FROM " + __classPrivateFieldGet(this, _Selection_sql, "f");
+        return "FROM " + this.#sql;
+    }
+    #join(type, selectable, as, on) {
+        let sql = this.#sql + "\n" + type + " " + fromAs(selectable, as);
+        if (on) {
+            sql += " ON " + condition(on);
+        }
+        return new _a(sql);
     }
     fullJoin(selectable, as, on) {
-        return __classPrivateFieldGet(this, _Selection_instances, "m", _Selection_join).call(this, "FULL JOIN", selectable, as, on);
+        return this.#join("FULL JOIN", selectable, as, on);
     }
     innerJoin(selectable, as, on) {
-        return __classPrivateFieldGet(this, _Selection_instances, "m", _Selection_join).call(this, "INNER JOIN", selectable, as, on);
+        return this.#join("INNER JOIN", selectable, as, on);
     }
     leftJoin(selectable, as, on) {
-        return __classPrivateFieldGet(this, _Selection_instances, "m", _Selection_join).call(this, "LEFT JOIN", selectable, as, on);
+        return this.#join("LEFT JOIN", selectable, as, on);
     }
     rightJoin(selectable, as, on) {
-        return __classPrivateFieldGet(this, _Selection_instances, "m", _Selection_join).call(this, "RIGHT JOIN", selectable, as, on);
+        return this.#join("RIGHT JOIN", selectable, as, on);
     }
     naturalJoin(selectable, as) {
-        return __classPrivateFieldGet(this, _Selection_instances, "m", _Selection_join).call(this, "NATURAL JOIN", selectable, as);
+        return this.#join("NATURAL JOIN", selectable, as);
     }
     crossJoin(selectable, as) {
-        return __classPrivateFieldGet(this, _Selection_instances, "m", _Selection_join).call(this, "CROSS JOIN", selectable, as);
+        return this.#join("CROSS JOIN", selectable, as);
     }
     from(selectable, as) {
-        return new _a(__classPrivateFieldGet(this, _Selection_sql, "f") + "," + fromAs(selectable, as));
+        return new _a(this.#sql + "," + fromAs(selectable, as));
     }
     select(columnsIn) {
         if (typeof columnsIn === "function")
@@ -730,15 +681,10 @@ class Selection {
         return new SqlSelectChain(sql);
     }
 }
-_a = Selection, _Selection_sql = new WeakMap(), _Selection_instances = new WeakSet(), _Selection_join = function _Selection_join(type, selectable, as, on) {
-    let sql = __classPrivateFieldGet(this, _Selection_sql, "f") + "\n" + type + " " + fromAs(selectable, as);
-    if (on) {
-        sql += " ON " + condition(on);
-    }
-    return new _a(sql);
-};
+_a = Selection;
 
 class SqlChainModify extends SqlStatement {
+    sql;
     constructor(sql) {
         super();
         this.sql = sql;
@@ -751,8 +697,7 @@ class SqlChainModify extends SqlStatement {
             columnsStr = "*";
         }
         else {
-            const res = selectColumnsOrTable(returns);
-            columnsStr = res.sqlColumns;
+            columnsStr = selectColumns(returns);
         }
         let sql = this.toString() + "\nRETURNING " + columnsStr;
         return new SqlTextStatementDataset(sql);
@@ -774,6 +719,7 @@ class SqlChainModify extends SqlStatement {
     }
 }
 class SqlInsertConflictBranch {
+    sql;
     constructor(sql) {
         this.sql = sql;
     }
@@ -801,6 +747,7 @@ class SqlInsertConflictBranch {
  * @public
  */
 class DbTable {
+    name;
     constructor(name) {
         this.name = name;
     }
@@ -861,6 +808,7 @@ class DbTable {
 
 /** @public */
 class DbTableQuery extends DbTable {
+    statement;
     constructor(name, statement) {
         super(name);
         this.statement = statement;
@@ -926,6 +874,11 @@ class DbTableQuery extends DbTable {
  * @public
  */
 class ColumnMeta {
+    type;
+    sqlType;
+    notNull;
+    isArray;
+    sqlDefault;
     constructor(type, 
     /** 数据库原始数据类型 */
     sqlType, 
@@ -953,6 +906,7 @@ class ColumnMeta {
  * @public
  */
 class YourTypeMap {
+    typeMap;
     static create(rawTypeMap) {
         return new this(rawTypeMap);
     }
@@ -978,18 +932,21 @@ function baseType(v) {
  * @public
  */
 class CustomDbType {
+    is;
+    name;
+    static bigint = new CustomDbType(baseType, "bigint");
+    static number = new CustomDbType(baseType, "number");
+    static string = new CustomDbType(baseType, "string");
+    static boolean = new CustomDbType(baseType, "boolean");
     constructor(is, name) {
         this.is = is;
         this.name = name;
     }
 }
-CustomDbType.bigint = new CustomDbType(baseType, "bigint");
-CustomDbType.number = new CustomDbType(baseType, "number");
-CustomDbType.string = new CustomDbType(baseType, "string");
-CustomDbType.boolean = new CustomDbType(baseType, "boolean");
 
 /** @public */
 class TypeChecker {
+    map;
     constructor(map) {
         this.map = map;
     }
@@ -1071,11 +1028,13 @@ function getErrStr(expect, actual) {
  * @public
  */
 class YourTable extends DbTableQuery {
+    define;
     constructor(name, define, sqlValue) {
         super(name, sqlValue);
         this.define = define;
         this.columns = Object.keys(define);
     }
+    columns;
     getColumnMeta(name) {
         return Reflect.get(this.define, name);
     }

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@asla/yoursql",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "",
   "type": "module",
   "types": "./dist/mod.d.ts",
+  "packageManager": "pnpm@10.4.0",
   "scripts": {
     "ci:test": "vitest run",
     "ci:build": "pnpm rollup -c build/rollup.config.js",
@@ -16,6 +17,7 @@
   "devDependencies": {
     "@microsoft/api-extractor": "^7.47.9",
     "@rollup/plugin-typescript": "^12.1.0",
+    "prettier": "^3.5.3",
     "rollup": "^4.22.4",
     "tslib": "^2.7.0",
     "typescript": "^5.6.2",
@@ -27,7 +29,8 @@
     "url": "https://github.com/asnowc/yoursql"
   },
   "exports": {
-    ".": "./dist/mod.js"
+    ".": "./dist/sql_gen.js",
+    "./client": "./dist/client.js"
   },
   "files": [
     "dist/**/*.js",