@asla/yoursql 0.8.2 → 0.8.4

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.d.ts

@@ -3,7 +3,9 @@ export * from "./sql_value/sql_value.ts";
 export * from "./select/type.ts";
 export * from "./select/DbTable.ts";
 export * from "./select/query_chain_select.ts";
-export * from "./select/query_chain_abstract.ts";
+export * from "./select/chain_base.ts";
+export * from "./select/chain_modify.ts";
+export * from "./select/chain_select.ts";
 export * from "./select/TableQuery.ts";
 export * from "./util.ts";
 export * from "./your_table/mod.ts";

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/chain_base.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.d.ts

@@ -1,7 +1,8 @@
 import { ConditionParam, Constructable } from "../util.ts";
 import type { TableType } from "./type.ts";
 import { Selection } from "./query_chain_select.ts";
-import { ChainModifyWhere, ChainOnConflict, ChainSelectWhere } from "./query_chain_abstract.ts";
+import { ChainDelete, ChainInsert, ChainUpdate } from "./chain_modify.ts";
+import { ChainSelect } from "./chain_select.ts";
 /**
  * 数据库表
  * @public
@@ -11,13 +12,13 @@ export declare class DbTable<T extends TableType> {
     constructor(name: string);
     fromAs(as?: string): Selection;
     /** 选择单表全部列 */
-    select(columns: "*", as?: string): ChainSelectWhere<T>;
+    select(columns: "*", as?: string): ChainSelect<T>;
     /** 选择单表  */
-    select(columns: Constructable<Record<string, boolean | string> | string>, as?: string): ChainSelectWhere<Record<string, any>>;
+    select(columns: Constructable<Record<string, boolean | string> | string>, as?: string): ChainSelect<Record<string, any>>;
     /** 选择单表  */
     select<R extends {}>(columns: Constructable<{
         [key in keyof R]: boolean | string;
-    } | string>, as?: string): ChainSelectWhere<R>;
+    } | string>, as?: string): ChainSelect<R>;
     /**
      * INSERT 语句，需要注意 SQL 注入
      * @example
@@ -25,7 +26,7 @@ export declare class DbTable<T extends TableType> {
      * 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>): ChainOnConflict<T>;
+    insert(columns: string, values: Constructable<string>): ChainInsert<T>;
     /**
      * UPDATE 语句，需要注意 SQL 注入
      * @example
@@ -36,8 +37,8 @@ export declare class DbTable<T extends TableType> {
      */
     update(values: Constructable<{
         [key in keyof T]?: string;
-    } | string>): ChainModifyWhere<T>;
-    delete(option?: DeleteOption): ChainModifyWhere<T>;
+    } | string>): ChainUpdate<T>;
+    delete(option?: DeleteOption): ChainDelete<T>;
     toSelect(): string;
 }
 /** @public */

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.d.ts

@@ -2,7 +2,7 @@ import { SqlValuesCreator } from "../sql_value/sql_value.ts";
 import { UpdateRowValue, TableType } from "./type.ts";
 import { Constructable } from "../util.ts";
 import { DbTable } from "./DbTable.ts";
-import { ChainModifyWhere, ChainOnConflict } from "./query_chain_abstract.ts";
+import { ChainInsert, ChainUpdate } from "./chain_modify.ts";
 /** @public */
 export declare class DbTableQuery<T extends TableType = Record<string, any>, C extends TableType = Partial<T>> extends DbTable<T> {
     private statement;
@@ -14,8 +14,8 @@ 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<UpdateRowValue<C> | UpdateRowValue<C>[]>): ChainOnConflict<T>;
-    insert(columns: string, values: Constructable<string>): ChainOnConflict<T>;
+    insert(values: Constructable<UpdateRowValue<C> | UpdateRowValue<C>[]>): ChainInsert<T>;
+    insert(columns: string, values: Constructable<string>): ChainInsert<T>;
     /**
      * UPDATE 语句，与 update() 不同的是，它会将值进行安全转换
      * @example
@@ -23,6 +23,6 @@ export declare class DbTableQuery<T extends TableType = Record<string, any>, C e
      * table.update({age:3, name:"hi"}, true) // "UPDATE table SET age=3, name='hi'"
      * ```
      */
-    updateFrom(values: Constructable<UpdateRowValue<T>>): ChainModifyWhere<T>;
+    updateFrom(values: Constructable<UpdateRowValue<T>>): ChainUpdate<T>;
 }
 //# sourceMappingURL=TableQuery.d.ts.map

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/chain_base.d.ts

@@ -0,0 +1,44 @@
+/** @public */
+export declare abstract class SqlStatement {
+    /** 获取 SQL 语句 */
+    abstract toString(): string;
+}
+/**
+ * 可选择项。可以是 table、查询结果等，它能被 select 语句选择
+ * @example
+ * ```ts
+ * declare const item: SqlStatementDataset
+ * await query(`select * from ${item.toSelect()}`)
+ *
+ * ```
+ * @public
+ */
+export interface SqlSelectable {
+    /**
+     * 转成子选择语句, 你可以使用 select form xxx 选择
+     * 如果是 table 则是 table name
+     * 如果是 选择语句，则是 (xxx)
+     */
+    toSelect(): string;
+}
+/** @public */
+export declare abstract class SqlStatementDataset<T> extends SqlStatement implements SqlSelectable {
+    /**
+     * 转成子选择语句, 你可以使用 select form xxx 选择
+     * 如果是 table 则是 table name
+     * 如果是 选择语句，则是 (xxx)
+     */
+    toSelect(): string;
+}
+/** @public */
+export declare class SqlTextStatementDataset<T> extends SqlStatementDataset<T> {
+    readonly sql: string;
+    constructor(sql: string);
+    toString(): string;
+}
+/**
+ * 推断查询结果的类型
+ * @public
+ */
+export type InferQueryResult<T> = T extends SqlStatementDataset<infer P> ? P : never;
+//# sourceMappingURL=chain_base.d.ts.map

package/dist/sql_gen/select/chain_base.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/chain_modify.d.ts

@@ -0,0 +1,33 @@
+import { ConditionParam, Constructable, SelectParam } from "../util.ts";
+import { TableType } from "./type.ts";
+import { SqlStatement, SqlStatementDataset } from "./chain_base.ts";
+/** @public */
+export interface ChainModifyReturning<T extends TableType = {}> extends SqlStatement {
+    returning(columns: "*"): SqlStatementDataset<T>;
+    returning(columns: Constructable<SelectParam>): SqlStatementDataset<Record<string, any>>;
+    returning<R extends TableType>(columns: Constructable<SelectParam>): SqlStatementDataset<R>;
+}
+/** @public */
+export interface ChainAfterConflictDo<T extends TableType = {}> {
+    doNotThing(): ChainModifyReturning<T>;
+    /**
+     * 需要注意 SQL 注入
+     */
+    doUpdate(set: Constructable<string | {
+        [key in keyof T]?: string;
+    }>): ChainModifyReturning<T>;
+    toString(): string;
+}
+/** @public */
+export interface ChainInsert<T extends TableType = {}> extends ChainModifyReturning<T> {
+    onConflict(option: Constructable<readonly (keyof T)[] | string>): ChainAfterConflictDo<T>;
+}
+/** @public */
+export interface ChainUpdate<T extends TableType = {}> extends ChainModifyReturning<T> {
+    where(where: Constructable<ConditionParam | void>): ChainModifyReturning<T>;
+}
+/** @public */
+export interface ChainDelete<T extends TableType = {}> extends ChainModifyReturning<T> {
+    where(where: Constructable<ConditionParam | void>): ChainModifyReturning<T>;
+}
+//# sourceMappingURL=chain_modify.d.ts.map

package/dist/sql_gen/select/chain_select.d.ts

@@ -0,0 +1,28 @@
+import { ConditionParam, Constructable, OrderByParam } from "../util.ts";
+import { SqlStatementDataset } from "./chain_base.ts";
+import { TableType } from "./type.ts";
+/** @public */
+export interface ChainSelect<T extends TableType> extends ChainSelectAfterWhere<T> {
+    where(param: Constructable<ConditionParam | void>): ChainSelectAfterWhere<T>;
+}
+/** @public */
+export interface ChainSelectAfterWhere<T extends TableType> extends ChainSelectAfterHaving<T> {
+    groupBy(columns: string | string[]): ChainSelectAfterGroupBy<T>;
+}
+/** @public */
+export interface ChainSelectAfterGroupBy<T extends TableType> extends ChainSelectAfterHaving<T> {
+    orderBy(param: Constructable<OrderByParam | void>): ChainSelectAfterOrderBy<T>;
+    having(param: Constructable<ConditionParam | void>): ChainSelectAfterHaving<T>;
+}
+/** @public */
+export interface ChainSelectAfterHaving<T extends TableType> extends ChainSelectAfterOrderBy<T> {
+    orderBy(param: Constructable<OrderByParam | void>): ChainSelectAfterOrderBy<T>;
+}
+/** @public */
+export interface ChainSelectAfterOrderBy<T extends TableType> extends SqlStatementDataset<T> {
+    limit(limit?: number | bigint, offset?: number | bigint): ChainSelectAfterLimit<T>;
+}
+/** @public */
+export interface ChainSelectAfterLimit<T extends TableType> extends SqlStatementDataset<T> {
+}
+//# sourceMappingURL=chain_select.d.ts.map