@asla/yoursql 0.11.3 → 0.12.0

package/dist/client/DbPoolConnection.d.ts

@@ -1,27 +1,5 @@
-import { DbQuery, MultipleQueryInput, QueryDataInput, QueryInput } from "./DbQuery.ts";
-import { type QueryRowsResult, type DbQueryBase, MultipleQueryResult } from "./DbQueryBase.ts";
-import type { SqlLike, TransactionMode } from "./interfaces.ts";
-/**
-
-/**
- * 池连接
- * @public
- */
-export declare class DbPoolConnection extends DbQuery {
-    #private;
-    constructor(conn: DbQueryBase, onRelease: (conn: DbQueryBase) => void);
-    begin(mode?: TransactionMode): Promise<void>;
-    query<T extends MultipleQueryResult = MultipleQueryResult>(sql: MultipleQueryInput): Promise<T>;
-    query<T = any>(sql: QueryDataInput<T>): Promise<QueryRowsResult<T>>;
-    query<T = any>(sql: QueryInput): Promise<QueryRowsResult<T>>;
-    execute(sql: QueryInput | MultipleQueryInput): Promise<void>;
-    /** @deprecated 不建议使用 */
-    multipleQuery<T extends MultipleQueryResult = MultipleQueryResult>(sql: SqlLike | SqlLike[]): Promise<T>;
-    rollback(): Promise<void>;
-    commit(): Promise<void>;
-    get released(): boolean;
-    /** 调用 release() 时，如果事务未提交，则抛出异常 */
-    release(): void;
-    [Symbol.dispose](): void;
-}
+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,22 +1,18 @@
 import { DbQuery } from './DbQuery.js';
 import { ConnectionNotAvailableError } from './errors.js';
 
-/**
-
-/**
- * 池连接
- * @public
- */
-class DbPoolConnection extends DbQuery {
-    constructor(conn, onRelease) {
+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.query("BEGIN" + (mode ? " TRANSACTION ISOLATION LEVEL " + mode : ""));
+        await this.execute("BEGIN" + (mode ? " TRANSACTION ISOLATION LEVEL " + mode : ""));
     }
     #conn;
     query(sql) {
@@ -41,11 +37,11 @@ class DbPoolConnection extends DbQuery {
     }
     //implement
     async rollback() {
-        await this.query("ROLLBACK");
+        await this.execute("ROLLBACK");
     }
     //implement
     async commit() {
-        await this.query("COMMIT");
+        await this.execute("COMMIT");
     }
     get released() {
         return !this.#conn;
@@ -58,10 +54,21 @@ class DbPoolConnection extends DbQuery {
             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 { DbPoolConnection };
+export { createDbPoolConnection };

package/dist/client/DbPoolTransaction.d.ts

@@ -1,31 +1,9 @@
-import { DbQuery, MultipleQueryInput, QueryDataInput, QueryInput } from "./DbQuery.ts";
-import type { MultipleQueryResult, QueryRowsResult } from "./DbQueryBase.ts";
-import type { DbPoolConnection } from "./DbPoolConnection.ts";
-import type { DbTransaction, SqlLike, TransactionMode } from "./interfaces.ts";
+import type { DbPoolConnection, DbPoolTransaction, TransactionMode } from "./interfaces.ts";
 /** @public */
 export type DbPoolTransactionOption = {
     errorRollback?: boolean;
     mode?: TransactionMode;
 };
-/**
- * @public
- * 池连接事务
- */
-export declare class DbPoolTransaction extends DbQuery implements DbTransaction {
-    #private;
-    readonly mode?: TransactionMode;
-    constructor(connect: () => Promise<DbPoolConnection>, option?: TransactionMode | DbPoolTransactionOption);
-    commit(): Promise<void>;
-    rollback(): Promise<void>;
-    savePoint(savePoint: string): Promise<void>;
-    rollbackTo(savePoint: string): Promise<void>;
-    query<T extends MultipleQueryResult = MultipleQueryResult>(sql: MultipleQueryInput): Promise<T>;
-    query<T extends object = any>(sql: QueryDataInput<T>): Promise<QueryRowsResult<T>>;
-    query<T extends object = any>(sql: QueryInput): Promise<QueryRowsResult<T>>;
-    execute(sql: QueryInput | MultipleQueryInput): Promise<void>;
-    /** @deprecated 不建议使用 */
-    multipleQuery<T extends MultipleQueryResult = MultipleQueryResult>(sql: SqlLike | SqlLike[]): Promise<T>;
-    get released(): boolean;
-    [Symbol.asyncDispose](): Promise<void>;
-}
+/** @public */
+export declare function createDbPoolTransaction(connect: () => Promise<DbPoolConnection>, option?: TransactionMode | DbPoolTransactionOption): DbPoolTransaction;
 //# sourceMappingURL=DbPoolTransaction.d.ts.map

package/dist/client/DbPoolTransaction.js

@@ -1,11 +1,7 @@
 import { DbQuery } from './DbQuery.js';
 import { ParallelQueryError, ConnectionNotAvailableError } from './errors.js';
 
-/**
- * @public
- * 池连接事务
- */
-class DbPoolTransaction extends DbQuery {
+class DbPoolTransactionImpl extends DbQuery {
     #errorRollback;
     mode;
     #begin;
@@ -26,23 +22,19 @@ class DbPoolTransaction extends DbQuery {
     #conn;
     async commit() {
         if (this.#conn) {
-            const promise = this.#conn.execute("COMMIT");
-            this.#release(this.#conn);
+            const conn = this.#conn;
+            const promise = conn.execute("COMMIT").then(() => conn.release(), (e) => conn.dispose());
             return promise;
         }
-        else {
-            this.#release(undefined);
-        }
+        this.#release(undefined);
     }
     async rollback() {
         if (this.#conn) {
-            const promise = this.#conn.execute("ROLLBACK");
-            this.#release(this.#conn);
+            const conn = this.#conn;
+            const promise = conn.execute("ROLLBACK").then(() => conn.release(), (e) => conn.dispose());
             return promise;
         }
-        else {
-            this.#release(undefined);
-        }
+        this.#release(undefined);
     }
     savePoint(savePoint) {
         return this.execute("SAVEPOINT " + savePoint);
@@ -51,7 +43,7 @@ class DbPoolTransaction extends DbQuery {
         return this.execute("ROLLBACK TO " + savePoint);
     }
     #pending;
-    #getConnQuery(call, callIfFirst = call, queryError) {
+    #getConnQuery(call, callIfFirst = call, queryErrorCatch) {
         if (this.#pending) {
             return Promise.reject(new ParallelQueryError());
         }
@@ -67,11 +59,8 @@ class DbPoolTransaction extends DbQuery {
                 }
                 this.#conn = conn;
                 let promise = callIfFirst(conn);
-                if (queryError) {
-                    promise = promise.catch((e) => {
-                        queryError();
-                        throw e;
-                    });
+                if (queryErrorCatch) {
+                    promise = promise.catch(queryErrorCatch);
                 }
                 return promise;
             }, (e) => {
@@ -81,11 +70,8 @@ class DbPoolTransaction extends DbQuery {
         }
         else {
             promise = call(this.#conn);
-            if (queryError) {
-                promise = promise.catch((e) => {
-                    queryError();
-                    throw e;
-                });
+            if (queryErrorCatch) {
+                promise = promise.catch(queryErrorCatch);
             }
         }
         this.#pending = promise;
@@ -94,12 +80,16 @@ class DbPoolTransaction extends DbQuery {
         });
     }
     #query(call, callIfFirst) {
-        const onError = () => {
+        const onError = (e) => {
             if (this.#errorRollback) {
-                this.rollback();
+                const passError = () => {
+                    throw e;
+                };
+                return this.rollback().then(passError, passError);
             }
             else {
                 this.#release(this.#conn);
+                throw e;
             }
         };
         return this.#getConnQuery(call, callIfFirst, onError);
@@ -148,5 +138,9 @@ class DbPoolTransaction extends DbQuery {
         return this.rollback();
     }
 }
+/** @public */
+function createDbPoolTransaction(connect, option) {
+    return new DbPoolTransactionImpl(connect, option);
+}
 
-export { DbPoolTransaction };
+export { createDbPoolTransaction };

package/dist/client/DbQuery.d.ts

@@ -16,7 +16,10 @@ export declare abstract class DbQuery {
     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() */
+    /**
+     * 执行多语句的方法
+     * @deprecated 不建议使用。改用 query()
+     */
     abstract multipleQuery<T extends MultipleQueryResult = MultipleQueryResult>(sql: SqlLike | SqlLike[]): Promise<T>;
     /** 单语句查询受影响的行 */
     queryCount(sql: QueryInput): Promise<number>;

package/dist/client/DbQueryPool.d.ts

@@ -1,7 +1,6 @@
 import { DbCursor, DbCursorOption } from "./DbCursor.ts";
-import { DbPoolConnection } from "./DbPoolConnection.ts";
 import { DbQuery } from "./DbQuery.ts";
-import { DbPool, DbTransaction, SqlLike, TransactionMode } from "./interfaces.ts";
+import { DbPool, DbPoolConnection, DbTransaction, SqlLike, TransactionMode } from "./interfaces.ts";
 import { QueryRowsResult } from "./DbQueryBase.ts";
 import { SqlStatementDataset, InferQueryResult } from "./_type.ts";
 /** @public */

package/dist/client/interfaces.d.ts

@@ -1,5 +1,4 @@
 import { DbQuery } from "./DbQuery.ts";
-import { DbPoolConnection } from "./DbPoolConnection.ts";
 import { DbCursor, DbCursorOption } from "./DbCursor.ts";
 import { SqlStatementDataset, SqlTemplate } from "./_type.ts";
 /**
@@ -9,6 +8,18 @@ import { SqlStatementDataset, SqlTemplate } from "./_type.ts";
 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";
 /**
@@ -49,6 +60,14 @@ export interface DbTransaction extends DbQuery, AsyncDisposable {
     /** 提交，并释放连接 */
     commit(): Promise<void>;
 }
+/**
+ * @public
+ * 池连接事务
+ */
+export interface DbPoolTransaction extends DbTransaction {
+    readonly mode?: TransactionMode;
+    get released(): boolean;
+}
 /**
  * 数据库连接池
  * @public

package/dist/client/mod.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asla/yoursql",
-  "version": "0.11.3",
+  "version": "0.12.0",
   "description": "",
   "type": "module",
   "types": "./dist/mod.d.ts",
@@ -21,7 +21,6 @@
     "rollup": "^4.22.4",
     "tslib": "^2.7.0",
     "typescript": "^5.6.2",
-    "typescritp": "^1.0.0",
     "vitest": "^2.1.1"
   },
   "repository": {