@asla/yoursql 0.8.1 → 0.8.3

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/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.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/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.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/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.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/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.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/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/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/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 };