@asla/yoursql 0.8.2 → 0.8.3

package/dist/client/DbCursor.js

@@ -0,0 +1,21 @@
+/** @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();
+        }
+    }
+}
+
+export { DbCursor };

package/dist/client/DbPoolConnection.js

@@ -0,0 +1,56 @@
+import { DbQuery } from './DbQuery.js';
+import { ConnectionNotAvailableError } from './errors.js';
+
+/**
+
+/**
+ * 池连接
+ * @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();
+    }
+}
+
+export { DbPoolConnection };

package/dist/client/DbPoolTransaction.js

@@ -0,0 +1,98 @@
+import { DbQuery } from './DbQuery.js';
+import { ParallelQueryError, ConnectionNotAvailableError } from './errors.js';
+
+/**
+ * @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 { DbPoolTransaction };

package/dist/client/DbQuery.js

@@ -0,0 +1,30 @@
+/**
+ * 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;
+    }
+}
+
+export { DbQuery };

package/dist/client/errors.js

@@ -0,0 +1,14 @@
+/** @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);
+    }
+}
+
+export { ConnectionNotAvailableError, ParallelQueryError };

package/dist/client/mod.js

@@ -0,0 +1,5 @@
+export { ConnectionNotAvailableError, ParallelQueryError } from './errors.js';
+export { DbQuery } from './DbQuery.js';
+export { DbCursor } from './DbCursor.js';
+export { DbPoolConnection } from './DbPoolConnection.js';
+export { DbPoolTransaction } from './DbPoolTransaction.js';

package/dist/sql_gen/mod.js

@@ -0,0 +1,19 @@
+import { pgSqlTransformer } from './sql_value/db_type.js';
+import { SqlValuesCreator } from './sql_value/sql_value.js';
+export { SqlRaw } from './sql_value/sql_value.js';
+export { DbTable } from './select/DbTable.js';
+export { Selection, SqlSelectChain } from './select/query_chain_select.js';
+export { SqlStatement, SqlStatementDataset, SqlTextStatementDataset } from './select/query_chain_abstract.js';
+export { DbTableQuery } from './select/TableQuery.js';
+export { getObjectListKeys, having, orderBy, selectColumns, where } from './util.js';
+export { TypeChecker } from './your_table/checker.js';
+export { ColumnMeta, CustomDbType, YourTypeMap } from './your_table/infer_db_type.js';
+export { YourTable } from './your_table/table.js';
+
+/**
+ * 默认的 SqlValuesCreator 实列
+ * @public
+ */
+const v = SqlValuesCreator.create(pgSqlTransformer);
+
+export { SqlValuesCreator, pgSqlTransformer, v };

package/dist/sql_gen/select/DbTable.js

@@ -0,0 +1,70 @@
+import { where } from '../util.js';
+import { Selection } from './query_chain_select.js';
+import { SqlChainModify } from './query_chain_insert.js';
+import { createUpdateSetFromObject } from './_statement.js';
+
+/**
+ * 数据库表
+ * @public
+ */
+class DbTable {
+    name;
+    constructor(name) {
+        this.name = name;
+    }
+    fromAs(as) {
+        return new Selection(this.name, as);
+    }
+    select(columns, as) {
+        return this.fromAs(as).select(columns);
+    }
+    /**
+     * 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 SqlChainModify(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();
+        switch (typeof values) {
+            case "object": {
+                let sql = createUpdateSetFromObject(values);
+                return new SqlChainModify("UPDATE " + this.name + " " + sql);
+            }
+            case "string":
+                return new SqlChainModify("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 SqlChainModify(sql);
+    }
+    toSelect() {
+        return this.name;
+    }
+}
+
+export { DbTable };

package/dist/sql_gen/select/TableQuery.js

@@ -0,0 +1,68 @@
+import { getObjectListKeys } from '../util.js';
+import { SqlChainModify } from './query_chain_insert.js';
+import { DbTable } from './DbTable.js';
+
+/** @public */
+class DbTableQuery extends DbTable {
+    statement;
+    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 {
+            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}`;
+        return new SqlChainModify(sql);
+    }
+    /**
+     * UPDATE 语句，与 update() 不同的是，它会将值进行安全转换
+     * @example
+     * ```ts
+     * table.update({age:3, name:"hi"}, true) // "UPDATE table SET age=3, name='hi'"
+     * ```
+     */
+    updateFrom(values) {
+        if (typeof values === "function")
+            values = values();
+        let setStr;
+        if (typeof values === "string")
+            setStr = values;
+        else {
+            const updateKey = Object.entries(values);
+            let setList = [];
+            for (const [k, v] of updateKey) {
+                if (v === undefined)
+                    continue;
+                setList.push(k + "= " + this.statement.toSqlStr(v));
+            }
+            setStr = setList.join(",\n");
+        }
+        if (!setStr)
+            throw new Error("值不能为空");
+        let sql = `UPDATE ${this.name} SET\n${setStr}`;
+        return new SqlChainModify(sql);
+    }
+}
+
+export { DbTableQuery };

package/dist/sql_gen/select/_statement.js

@@ -0,0 +1,60 @@
+function condition(conditions, type = "AND") {
+    if (typeof conditions === "function")
+        conditions = conditions();
+    if (!conditions)
+        return;
+    if (typeof conditions === "string")
+        return conditions;
+    else {
+        if (conditions.length) {
+            let sql = "";
+            type = " " + type + " ";
+            sql += conditions[0];
+            for (let i = 1; i < conditions.length; i++)
+                sql += type + conditions[i];
+            return sql;
+        }
+        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("值不能为空");
+}
+
+export { condition, createUpdateSetFromObject };

package/dist/sql_gen/select/query_chain_abstract.js

@@ -0,0 +1,27 @@
+/** @public */
+class SqlStatement {
+}
+/** @public */
+class SqlStatementDataset extends SqlStatement {
+    /**
+     * 转成子选择语句, 你可以使用 select form xxx 选择
+     * 如果是 table 则是 table name
+     * 如果是 选择语句，则是 (xxx)
+     */
+    toSelect() {
+        return "(" + this.toString() + ")";
+    }
+}
+/** @public */
+class SqlTextStatementDataset extends SqlStatementDataset {
+    sql;
+    constructor(sql) {
+        super();
+        this.sql = sql;
+    }
+    toString() {
+        return this.sql;
+    }
+}
+
+export { SqlStatement, SqlStatementDataset, SqlTextStatementDataset };

package/dist/sql_gen/select/query_chain_insert.js

@@ -0,0 +1,64 @@
+import { selectColumns, where } from '../util.js';
+import { createUpdateSetFromObject } from './_statement.js';
+import { SqlStatement, SqlTextStatementDataset } from './query_chain_abstract.js';
+
+class SqlChainModify extends SqlStatement {
+    sql;
+    constructor(sql) {
+        super();
+        this.sql = sql;
+    }
+    returning(returns) {
+        if (typeof returns === "function")
+            returns = returns();
+        let columnsStr;
+        if (returns === "*") {
+            columnsStr = "*";
+        }
+        else {
+            columnsStr = selectColumns(returns);
+        }
+        let sql = this.toString() + "\nRETURNING " + columnsStr;
+        return new SqlTextStatementDataset(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 SqlInsertConflictBranch(sql);
+    }
+    where(where$1) {
+        const sql = where(where$1);
+        return new SqlChainModify(this.toString() + sql);
+    }
+    toString() {
+        return this.sql;
+    }
+}
+class SqlInsertConflictBranch {
+    sql;
+    constructor(sql) {
+        this.sql = sql;
+    }
+    doUpdate(set) {
+        if (typeof set === "function")
+            set = set();
+        let sql = this.sql;
+        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 SqlChainModify(sql);
+    }
+    doNotThing() {
+        return new SqlChainModify(this.sql + " DO NOTHING");
+    }
+}
+
+export { SqlChainModify, SqlInsertConflictBranch };

package/dist/sql_gen/select/query_chain_select.js

@@ -0,0 +1,105 @@
+import { SqlTextStatementDataset } from './query_chain_abstract.js';
+import { where, having, orderBy, selectColumns } from '../util.js';
+import { condition } from './_statement.js';
+
+var _a;
+/**
+ * @public ChainSelectWhere 的默认实现
+ */
+class SqlSelectChain extends SqlTextStatementDataset {
+    where(param) {
+        return new SqlSelectChain(this.toString() + where(param));
+    }
+    groupBy(columns) {
+        let sql = this.toString();
+        if (typeof columns === "string")
+            sql += " GROUP BY " + columns;
+        else
+            sql += " GROUP BY " + columns.join(",");
+        return new SqlSelectChain(sql);
+    }
+    having(param) {
+        return new SqlSelectChain(this.toString() + having(param));
+    }
+    orderBy(param) {
+        return new SqlSelectChain(this.toString() + orderBy(param));
+    }
+    limit(limit, offset) {
+        let sql = this.toString();
+        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 SqlTextStatementDataset(sql);
+    }
+}
+function fromAs(selectable, as) {
+    if (typeof selectable === "function")
+        selectable = selectable();
+    let sql = typeof selectable === "string" ? selectable : selectable.toSelect();
+    if (as)
+        sql += " AS " + as;
+    return sql;
+}
+/** @public */
+class Selection {
+    static from(selectable, as) {
+        return new this(selectable, as);
+    }
+    #sql;
+    constructor(selectable, as) {
+        this.#sql = fromAs(selectable, as);
+    }
+    toString() {
+        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 this.#join("FULL JOIN", selectable, as, on);
+    }
+    innerJoin(selectable, as, on) {
+        return this.#join("INNER JOIN", selectable, as, on);
+    }
+    leftJoin(selectable, as, on) {
+        return this.#join("LEFT JOIN", selectable, as, on);
+    }
+    rightJoin(selectable, as, on) {
+        return this.#join("RIGHT JOIN", selectable, as, on);
+    }
+    naturalJoin(selectable, as) {
+        return this.#join("NATURAL JOIN", selectable, as);
+    }
+    crossJoin(selectable, as) {
+        return this.#join("CROSS JOIN", selectable, as);
+    }
+    from(selectable, as) {
+        return new _a(this.#sql + "," + fromAs(selectable, as));
+    }
+    select(columnsIn) {
+        if (typeof columnsIn === "function")
+            columnsIn = columnsIn();
+        let sql = "SELECT " + selectColumns(columnsIn);
+        sql += "\n" + this.toString();
+        return new SqlSelectChain(sql);
+    }
+}
+_a = Selection;
+
+export { Selection, SqlSelectChain };

package/dist/sql_gen/sql_value/db_type.js

@@ -0,0 +1,40 @@
+import { SqlValuesCreator } from './sql_value.js';
+
+/** @public PgSql 转换器 */
+const pgSqlTransformer = new Map([
+    [
+        Array,
+        function encodePgArray(value) {
+            if (value.length === 0)
+                return "NULL";
+            const valueStr = [];
+            let type;
+            let basicType;
+            for (let i = 0; i < value.length; i++) {
+                if (value[i] === null || value[i] === undefined)
+                    valueStr[i] = this.toSqlStr(value[i]);
+                else if (type) {
+                    valueStr[i] = this.toSqlStr(value[i], type);
+                }
+                else {
+                    basicType = typeof value[i];
+                    if (basicType === "object") {
+                        type = this.getClassType(value[i]);
+                    }
+                    else
+                        type = basicType;
+                    valueStr[i] = this.toSqlStr(value[i], type);
+                }
+            }
+            return "ARRAY[" + valueStr.join(",") + "]";
+        },
+    ],
+    [
+        Date,
+        function (value) {
+            return SqlValuesCreator.string(value.toISOString());
+        },
+    ],
+]);
+
+export { pgSqlTransformer };