@asla/yoursql 0.13.0 → 0.14.0

package/dist/client/DbCursor.js

@@ -1,21 +0,0 @@
-/** @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

@@ -1,5 +0,0 @@
-import { type DbQueryBase } from "./DbQueryBase.ts";
-import type { DbPoolConnection } from "./interfaces.ts";
-/** @public */
-export declare function createDbPoolConnection(conn: DbQueryBase, onRelease: (conn: DbQueryBase) => void, onDispose?: (conn: DbQueryBase) => void): DbPoolConnection;
-//# sourceMappingURL=DbPoolConnection.d.ts.map

package/dist/client/DbPoolConnection.js

@@ -1,74 +0,0 @@
-import { DbQuery } from './DbQuery.js';
-import { ConnectionNotAvailableError } from './errors.js';
-
-class DbPoolConnectionImpl extends DbQuery {
-    constructor(conn, onRelease, onDispose = onRelease) {
-        super();
-        this.#conn = conn;
-        this.#onRelease = onRelease;
-        this.#onDispose = onDispose;
-    }
-    #onRelease;
-    #onDispose;
-    //implement
-    async begin(mode) {
-        await this.execute("BEGIN" + (mode ? " TRANSACTION ISOLATION LEVEL " + mode : ""));
-    }
-    #conn;
-    query(sql) {
-        if (!this.#conn)
-            return Promise.reject(new ConnectionNotAvailableError("Connection already release"));
-        if (typeof sql === "function")
-            sql = sql();
-        return this.#conn.query(sql);
-    }
-    execute(sql) {
-        if (!this.#conn)
-            return Promise.reject(new ConnectionNotAvailableError("Connection already release"));
-        if (typeof sql === "function")
-            sql = sql();
-        return this.#conn.execute(sql);
-    }
-    /** @deprecated 不建议使用 */
-    multipleQuery(sql) {
-        if (!this.#conn)
-            return Promise.reject(new ConnectionNotAvailableError("Connection already release"));
-        return this.#conn.multipleQuery(sql);
-    }
-    //implement
-    async rollback() {
-        await this.execute("ROLLBACK");
-    }
-    //implement
-    async commit() {
-        await this.execute("COMMIT");
-    }
-    get released() {
-        return !this.#conn;
-    }
-    /** 调用 release() 时，如果事务未提交，则抛出异常 */
-    release() {
-        const conn = this.#conn;
-        if (conn) {
-            this.#conn = undefined;
-            this.#onRelease(conn);
-        }
-    }
-    dispose() {
-        const conn = this.#conn;
-        if (conn) {
-            this.#conn = undefined;
-            this.#onDispose(conn);
-        }
-    }
-    //implement
-    [Symbol.dispose]() {
-        return this.release();
-    }
-}
-/** @public */
-function createDbPoolConnection(conn, onRelease, onDispose = onRelease) {
-    return new DbPoolConnectionImpl(conn, onRelease, onDispose);
-}
-
-export { createDbPoolConnection };

package/dist/client/DbPoolTransaction.d.ts

@@ -1,9 +0,0 @@
-import type { DbPoolConnection, DbPoolTransaction, TransactionMode } from "./interfaces.ts";
-/** @public */
-export type DbPoolTransactionOption = {
-    errorRollback?: boolean;
-    mode?: TransactionMode;
-};
-/** @public */
-export declare function createDbPoolTransaction(connect: () => Promise<DbPoolConnection>, option?: TransactionMode | DbPoolTransactionOption): DbPoolTransaction;
-//# sourceMappingURL=DbPoolTransaction.d.ts.map

package/dist/client/DbPoolTransaction.js

@@ -1,146 +0,0 @@
-import { DbQuery } from './DbQuery.js';
-import { ParallelQueryError, ConnectionNotAvailableError } from './errors.js';
-
-class DbPoolTransactionImpl extends DbQuery {
-    #errorRollback;
-    mode;
-    #begin;
-    constructor(connect, option) {
-        super();
-        if (option) {
-            if (typeof option === "string")
-                this.mode = option;
-            else {
-                this.mode = option.mode;
-                this.#errorRollback = option.errorRollback;
-            }
-        }
-        this.#begin = "BEGIN" + (this.mode ? " TRANSACTION ISOLATION LEVEL " + this.mode : "");
-        this.#connect = connect;
-    }
-    #connect;
-    #conn;
-    async commit() {
-        if (this.#conn) {
-            const conn = this.#conn;
-            const promise = conn.execute("COMMIT").then(() => conn.release(), (e) => conn.dispose());
-            return promise;
-        }
-        this.#release(undefined);
-    }
-    async rollback() {
-        if (this.#conn) {
-            const conn = this.#conn;
-            const promise = conn.execute("ROLLBACK").then(() => conn.release(), (e) => conn.dispose());
-            return promise;
-        }
-        this.#release(undefined);
-    }
-    savePoint(savePoint) {
-        return this.execute("SAVEPOINT " + savePoint);
-    }
-    rollbackTo(savePoint) {
-        return this.execute("ROLLBACK TO " + savePoint);
-    }
-    #pending;
-    #getConnQuery(call, callIfFirst = call, queryErrorCatch) {
-        if (this.#pending) {
-            return Promise.reject(new ParallelQueryError());
-        }
-        if (this.#error) {
-            return Promise.reject(this.#error);
-        }
-        let promise;
-        if (!this.#conn) {
-            promise = this.#connect().then((conn) => {
-                if (this.released) {
-                    conn.release();
-                    throw this.#error;
-                }
-                this.#conn = conn;
-                let promise = callIfFirst(conn);
-                if (queryErrorCatch) {
-                    promise = promise.catch(queryErrorCatch);
-                }
-                return promise;
-            }, (e) => {
-                this.#release(undefined);
-                throw e;
-            });
-        }
-        else {
-            promise = call(this.#conn);
-            if (queryErrorCatch) {
-                promise = promise.catch(queryErrorCatch);
-            }
-        }
-        this.#pending = promise;
-        return promise.finally(() => {
-            this.#pending = undefined;
-        });
-    }
-    #query(call, callIfFirst) {
-        const onError = (e) => {
-            if (this.#errorRollback) {
-                const passError = () => {
-                    throw e;
-                };
-                return this.rollback().then(passError, passError);
-            }
-            else {
-                this.#release(this.#conn);
-                throw e;
-            }
-        };
-        return this.#getConnQuery(call, callIfFirst, onError);
-    }
-    query(sql) {
-        return this.#query((conn) => {
-            return conn.query(sql);
-        }, async (conn) => {
-            if (typeof sql === "function")
-                sql = sql();
-            const isArray = sql instanceof Array;
-            const result = await conn.query(isArray ? [this.#begin, ...sql] : [this.#begin, sql]);
-            if (isArray)
-                return result.slice(1);
-            else
-                return result[1];
-        });
-    }
-    async execute(sql) {
-        return this.#query((conn) => {
-            return conn.execute(sql);
-        }, (conn) => {
-            if (typeof sql === "function")
-                sql = sql();
-            return conn.execute(sql instanceof Array ? [this.#begin, ...sql] : [this.#begin, sql]);
-        });
-    }
-    /** @deprecated 不建议使用 */
-    multipleQuery(sql) {
-        return this.#query((conn) => {
-            return conn.multipleQuery(sql);
-        }, (conn) => {
-            return conn.multipleQuery(sql instanceof Array ? [this.#begin, ...sql] : [this.#begin, sql]);
-        });
-    }
-    #error;
-    #release(conn, error = new ConnectionNotAvailableError("Connection already release")) {
-        this.#error = error;
-        this.#conn = undefined;
-        conn?.release();
-    }
-    get released() {
-        return !!this.#error;
-    }
-    [Symbol.asyncDispose]() {
-        return this.rollback();
-    }
-}
-/** @public */
-function createDbPoolTransaction(connect, option) {
-    return new DbPoolTransactionImpl(connect, option);
-}
-
-export { createDbPoolTransaction };

package/dist/client/DbQuery.d.ts

@@ -1,50 +0,0 @@
-import { SqlLike } from "./interfaces.ts";
-import { MultipleQueryResult, QueryRowsResult } from "./DbQueryBase.ts";
-import { SqlStatementDataset } from "./_type.ts";
-/** @public */
-export type QueryInput = SqlLike | (() => SqlLike);
-/** @public */
-export type QueryDataInput<T> = SqlStatementDataset<T> | (() => SqlStatementDataset<T>);
-/** @public */
-export type MultipleQueryInput = SqlLike[] | (() => SqlLike[]);
-/**
- * SQL 查询相关操作
- * @public
- */
-export declare abstract class DbQuery {
-    abstract execute(sql: QueryInput | MultipleQueryInput): Promise<void>;
-    abstract query<T extends MultipleQueryResult = MultipleQueryResult>(sql: MultipleQueryInput): Promise<T>;
-    abstract query<T = any>(sql: QueryDataInput<T>): Promise<QueryRowsResult<T>>;
-    abstract query<T = any>(sql: QueryInput): Promise<QueryRowsResult<T>>;
-    /**
-     * 执行多语句的方法
-     * @deprecated 不建议使用。改用 query()
-     */
-    abstract multipleQuery<T extends MultipleQueryResult = MultipleQueryResult>(sql: SqlLike | SqlLike[]): Promise<T>;
-    /** 单语句查询受影响的行 */
-    queryCount(sql: QueryInput): Promise<number>;
-    /** 单语句查询，不应查询多语句，否则返回错误值  */
-    queryRows<T = any>(sql: QueryDataInput<T>): Promise<T[]>;
-    /** 单语句查询，不应查询多语句，否则返回错误值  */
-    queryRows<T = any>(sql: QueryInput): Promise<T[]>;
-    /** 单语句查询，只返回第一行。如果查询没有返回行，则抛出异常。 */
-    queryFirstRow<T = any>(sql: QueryDataInput<T>): Promise<T>;
-    queryFirstRow<T = any>(sql: QueryInput): Promise<T>;
-    /**
-     * 查询行
-     * 不应查询单语句，否则返回错误值
-     *  @deprecated 不建议使用。
-     */
-    multipleQueryRows<T extends any[] = any[]>(sql: SqlLike | SqlLike[]): Promise<T[]>;
-    /**
-     * 指定某一列为key，返回 key 到 row 的映射
-     * 单语句查询，不应查询多语句，否则返回错误值
-     */
-    queryMap<T extends Record<string, any> = Record<string, any>, K extends keyof T = string>(sql: QueryDataInput<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: QueryInput, key: K): Promise<Map<T[K], T>>;
-}
-//# sourceMappingURL=DbQuery.d.ts.map

package/dist/client/DbQuery.js

@@ -1,42 +0,0 @@
-/**
- * SQL 查询相关操作
- * @public
- */
-class DbQuery {
-    /** 单语句查询受影响的行 */
-    queryCount(sql) {
-        return this.query(sql).then((res) => {
-            if (res.rowCount === null)
-                return 0;
-            return res.rowCount;
-        });
-    }
-    queryRows(sql) {
-        return this.query(sql).then((res) => res.rows);
-    }
-    queryFirstRow(sql) {
-        return this.query(sql).then(({ rows, rowCount }) => {
-            if (rows.length === 0)
-                throw new Error("Query did not return any rows");
-            return rows[0];
-        });
-    }
-    /**
-     * 查询行
-     * 不应查询单语句，否则返回错误值
-     *  @deprecated 不建议使用。
-     */
-    multipleQueryRows(sql) {
-        return this.multipleQuery(sql).then((res) => res.map((item) => item.rows ?? []));
-    }
-    async queryMap(sql, key) {
-        const { rows } = await this.query(sql);
-        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/DbQueryBase.d.ts

@@ -1,38 +0,0 @@
-import { SqlTemplate } from "./_type.ts";
-import { SqlLike } from "./interfaces.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 interface DbQueryBase {
-    /** 单语句查询， 忽略返回值 */
-    execute(sql: SqlLike | SqlLike[]): Promise<void>;
-    /** 单语句查询。单个 SqlLike 不应包含多语句，否则返回错误值  */
-    query<T = any>(sql: SqlLike): Promise<QueryRowsResult<T>>;
-    /** 多语句查询 */
-    query<T extends MultipleQueryResult = MultipleQueryResult>(sql: SqlLike[]): Promise<T>;
-    query(sql: SqlLike[] | SqlLike): Promise<unknown[] | unknown>;
-    /** 多语句查询 */
-    multipleQuery<T extends MultipleQueryResult = MultipleQueryResult>(sql: SqlLike | SqlLike[]): Promise<T>;
-}
-/**
- * 将 SqlLike 转换为字符串
- * @public
- *
- */
-export declare function sqlLikeToString(sqlLike: SqlLike): string;
-/** @public */
-export declare function isSqlTemplate(obj: any): obj is SqlTemplate;
-//# sourceMappingURL=DbQueryBase.d.ts.map

package/dist/client/DbQueryBase.js

@@ -1,32 +0,0 @@
-/**
- * 将 SqlLike 转换为字符串
- * @public
- *
- */
-function sqlLikeToString(sqlLike) {
-    if (typeof sqlLike === "string") {
-        return sqlLike;
-    }
-    else {
-        if (isSqlTemplate(sqlLike)) {
-            const { templates } = sqlLike;
-            const textArgs = sqlLike.toTextArgs();
-            let sql = templates[0];
-            for (let i = 1; i < templates.length; i++) {
-                sql += textArgs[i - 1] + templates[i];
-            }
-            return sql;
-        }
-        else {
-            return sqlLike.genSql();
-        }
-    }
-}
-/** @public */
-function isSqlTemplate(obj) {
-    if (typeof obj !== "object" || obj === null)
-        return false;
-    return Array.isArray(obj.templates) && Array.isArray(obj.args) && typeof obj.toTextArgs === "function";
-}
-
-export { isSqlTemplate, sqlLikeToString };

package/dist/client/DbQueryPool.d.ts

@@ -1,39 +0,0 @@
-import { DbCursor, DbCursorOption } from "./DbCursor.ts";
-import { DbQuery } from "./DbQuery.ts";
-import { DbPool, DbPoolConnection, DbTransaction, SqlLike, TransactionMode } from "./interfaces.ts";
-import { QueryRowsResult } from "./DbQueryBase.ts";
-import { SqlStatementDataset, InferQueryResult } from "./_type.ts";
-/** @public */
-export interface ExecutableSQL<T = unknown> {
-    genSql(): string;
-    then(resolve: (data: T) => void, reject: () => void): void;
-}
-/** @public */
-export interface QueryableDataSQL<Raw, Res = QueryRowsResult<Raw>> extends ExecutableSQL<Res> {
-    query(): Promise<QueryRowsResult<Raw>>;
-    queryCount(): Promise<number>;
-    queryRows(): Promise<Raw[]>;
-    queryFirstRow(): Promise<Raw>;
-    queryMap<K>(key: string): Promise<Map<K, Raw>>;
-    cursor(): Promise<DbCursor<Raw>>;
-}
-/**
- * @public
- * 池链接查询
- */
-export declare abstract class DbQueryPool extends DbQuery implements DbPool {
-    abstract connect(): Promise<DbPoolConnection>;
-    /** 连接池空闲链接数量 */
-    abstract idleCount: number;
-    /** 连接池总链接数量 */
-    abstract totalCount: number;
-    abstract begin(mode?: TransactionMode): DbTransaction;
-    abstract cursor<T extends {}>(sql: SqlStatementDataset<T>): Promise<DbCursor<T>>;
-    abstract cursor<T>(sql: SqlLike, option?: DbCursorOption): Promise<DbCursor<T>>;
-    createQueryableSQL<Raw>(statement: SqlStatementDataset<Raw>): QueryableDataSQL<Raw, void>;
-    createQueryableSQL<Raw>(statement: SqlLike): QueryableDataSQL<Raw, void>;
-    createQueryableSQL<T extends SqlStatementDataset<any>, Res>(statement: T, transform: (queryable: DbQueryPool, statement: T) => Promise<Res>): QueryableDataSQL<InferQueryResult<T>, Awaited<Res>>;
-    createQueryableSQL<Raw, Res>(statement: SqlLike, transform: (queryable: DbQueryPool, statement: SqlLike) => Promise<Res>): QueryableDataSQL<Raw, Res>;
-    createExecutableSQL(statement: SqlLike): ExecutableSQL<void>;
-}
-//# sourceMappingURL=DbQueryPool.d.ts.map

package/dist/client/DbQueryPool.js

@@ -1,56 +0,0 @@
-import { DbQuery } from './DbQuery.js';
-
-/**
- * @public
- * 池链接查询
- */
-class DbQueryPool extends DbQuery {
-    createQueryableSQL(statement, transform) {
-        return new QueryableSqlImpl(this, statement, transform);
-    }
-    createExecutableSQL(statement) {
-        return new QueryableSqlImpl(this, statement);
-    }
-}
-class QueryableSqlImpl {
-    queryClient;
-    statement;
-    transform;
-    constructor(queryClient, statement, transform = defaultTransform) {
-        this.queryClient = queryClient;
-        this.statement = statement;
-        this.transform = transform;
-    }
-    genSql() {
-        return this.statement.toString();
-    }
-    toString() {
-        return this.genSql();
-    }
-    query() {
-        return this.queryClient.query(this.statement);
-    }
-    queryCount() {
-        return this.queryClient.queryCount(this.statement);
-    }
-    queryRows() {
-        return this.queryClient.queryRows(this.statement);
-    }
-    queryFirstRow() {
-        return this.queryClient.queryFirstRow(this.statement);
-    }
-    queryMap(key) {
-        return this.queryClient.queryMap(this.statement, key);
-    }
-    cursor() {
-        return this.queryClient.cursor(this.statement);
-    }
-    then(resolve, reject) {
-        this.transform(this.queryClient, this.statement).then(resolve, reject);
-    }
-}
-function defaultTransform(queryClient, statement) {
-    return queryClient.execute(statement);
-}
-
-export { DbQueryPool };

package/dist/client/_type.d.ts

@@ -1,2 +0,0 @@
-export type { SqlStatementDataset, SqlTemplate, SqlTextTemplate, InferQueryResult } from "../sql_gen/mod.ts";
-//# sourceMappingURL=_type.d.ts.map

package/dist/client/errors.d.ts

@@ -1,9 +0,0 @@
-/** @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

@@ -1,14 +0,0 @@
-/** @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

@@ -1,87 +0,0 @@
-import { DbQuery } from "./DbQuery.ts";
-import { DbCursor, DbCursorOption } from "./DbCursor.ts";
-import { SqlStatementDataset, SqlTemplate } from "./_type.ts";
-/**
- * 数据库连接
- * @public
- */
-export interface DbConnection extends DbQuery, AsyncDisposable {
-    close(): Promise<void>;
-}
-/**
- * 数据库池连接
- * @public
- */
-export interface DbPoolConnection extends DbQuery, Disposable {
-    release(): void;
-    dispose(): void;
-    begin(mode?: TransactionMode): Promise<void>;
-    commit(): Promise<void>;
-    rollback(): Promise<void>;
-    get released(): boolean;
-}
-/** @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 DbPoolTransaction extends DbTransaction {
-    readonly mode?: TransactionMode;
-    get released(): boolean;
-}
-/**
- * 数据库连接池
- * @public
- */
-export interface DbPool {
-    connect(): Promise<DbPoolConnection>;
-    idleCount: number;
-    totalCount: number;
-    begin(mode?: TransactionMode): DbTransaction;
-    cursor<T extends {}>(sql: SqlStatementDataset<T>): Promise<DbCursor<T>>;
-    cursor<T>(sql: SqlLike, option?: DbCursorOption): Promise<DbCursor<T>>;
-}
-/** @public */
-export type SqlLike = {
-    genSql(): string;
-} | SqlTemplate | string;
-//# sourceMappingURL=interfaces.d.ts.map

package/dist/client/mod.d.ts

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

package/dist/client/mod.js

@@ -1,7 +0,0 @@
-export { ConnectionNotAvailableError, ParallelQueryError } from './errors.js';
-export { isSqlTemplate, sqlLikeToString } from './DbQueryBase.js';
-export { DbQuery } from './DbQuery.js';
-export { DbCursor } from './DbCursor.js';
-export { createDbPoolConnection } from './DbPoolConnection.js';
-export { createDbPoolTransaction } from './DbPoolTransaction.js';
-export { DbQueryPool } from './DbQueryPool.js';