@asla/yoursql 0.8.7 → 0.8.8

package/dist/client/DbPoolConnection.d.ts

@@ -1,7 +1,7 @@
 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";
+import type { MultipleQueryResult, QueryRowsResult, DbQueryBase } from "./DbQueryBase.ts";
+import type { StringLike, TransactionMode } from "./interfaces.ts";
 /**
 
 /**
@@ -10,15 +10,11 @@ import type { DbConnection, TransactionMode } from "./interfaces.ts";
  */
 export declare class DbPoolConnection extends DbQuery {
     #private;
-    constructor(conn: DbConnection, onRelease: () => void);
+    constructor(conn: DbQueryBase, onRelease: (conn: DbQueryBase) => 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>;
+    query<T = any>(sql: StringLike): Promise<QueryRowsResult<T>>;
+    multipleQuery<T extends MultipleQueryResult = MultipleQueryResult>(sql: StringLike): Promise<T>;
     rollback(): Promise<void>;
     commit(): Promise<void>;
     get released(): boolean;

package/dist/client/DbPoolConnection.js

@@ -42,9 +42,10 @@ class DbPoolConnection extends DbQuery {
     }
     /** 调用 release() 时，如果事务未提交，则抛出异常 */
     release() {
-        if (this.#conn) {
+        const conn = this.#conn;
+        if (conn) {
             this.#conn = undefined;
-            this.#onRelease();
+            this.#onRelease(conn);
         }
     }
     //implement

package/dist/client/DbPoolTransaction.d.ts

@@ -1,8 +1,8 @@
 import type { SqlStatementDataset } from "../sql_gen/mod.ts";
 import { DbQuery } from "./DbQuery.ts";
-import type { MultipleQueryResult, QueryRowsResult } from "./DbQuery.ts";
+import type { MultipleQueryResult, QueryRowsResult } from "./DbQueryBase.ts";
 import type { DbPoolConnection } from "./DbPoolConnection.ts";
-import type { DbTransaction, TransactionMode } from "./interfaces.ts";
+import type { DbTransaction, StringLike, TransactionMode } from "./interfaces.ts";
 /** @public */
 export type DbPoolTransactionOption = {
     errorRollback?: boolean;
@@ -21,13 +21,9 @@ export declare class DbPoolTransaction extends DbQuery implements DbTransaction
     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>>;
+    query<T extends object = any>(sql: StringLike): Promise<QueryRowsResult<T>>;
     multipleQuery<T extends MultipleQueryResult = MultipleQueryResult>(sql: SqlStatementDataset<T>): Promise<T>;
-    multipleQuery<T extends MultipleQueryResult = MultipleQueryResult>(sql: {
-        toString(): string;
-    }): Promise<T>;
+    multipleQuery<T extends MultipleQueryResult = MultipleQueryResult>(sql: StringLike): Promise<T>;
     get released(): boolean;
     [Symbol.asyncDispose](): Promise<void>;
 }

package/dist/client/DbQuery.d.ts

@@ -1,45 +1,22 @@
 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;
+import { StringLike } from "./interfaces.ts";
+import { MultipleQueryResult, DbQueryBase, QueryRowsResult } from "./DbQueryBase.ts";
 /**
  * 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>;
+export declare abstract class DbQuery implements DbQueryBase {
+    abstract query<T = any>(sql: StringLike): Promise<QueryRowsResult<T>>;
+    abstract multipleQuery<T extends MultipleQueryResult = MultipleQueryResult>(sql: StringLike): Promise<T>;
     /** 单语句查询受影响的行 */
-    queryCount(sql: string | {
-        toString(): string;
-    }): Promise<number>;
-    /** 单语句查询，不应查询条语句，否则返回错误值  */
+    queryCount(sql: string | StringLike): Promise<number>;
+    /** 单语句查询，不应查询多语句，否则返回错误值  */
     queryRows<T = any>(sql: SqlStatementDataset<T>): Promise<T[]>;
-    /** 单语句查询，不应查询条语句，否则返回错误值  */
-    queryRows<T = any>(sql: {
-        toString(): string;
-    }): Promise<T[]>;
+    /** 单语句查询，不应查询多语句，否则返回错误值  */
+    queryRows<T = any>(sql: StringLike): Promise<T[]>;
+    /** 单语句查询，只返回第一行。如果查询没有返回行，则抛出异常。 */
+    queryFirstRow<T = any>(sql: SqlStatementDataset<T>): Promise<T>;
+    queryFirstRow<T = any>(sql: StringLike): Promise<T>;
     /**
      * 查询行
      * 不应查询单条语句，否则返回错误值
@@ -47,22 +24,18 @@ export declare abstract class DbQuery {
     multipleQueryRows<T extends any[] = any[]>(sql: SqlStatementDataset<T>): Promise<T[]>;
     /**
      * 查询行
-     * 不应查询条语句，否则返回错误值
+     * 不应查询单语句，否则返回错误值
      */
-    multipleQueryRows<T extends any[] = any[]>(sql: {
-        toString(): string;
-    }): Promise<T[]>;
+    multipleQueryRows<T extends any[] = any[]>(sql: StringLike): 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>>;
+    queryMap<T extends Record<string, any> = Record<string, any>, K extends keyof T = string>(sql: StringLike, key: K): Promise<Map<T[K], T>>;
 }
 //# sourceMappingURL=DbQuery.d.ts.map

package/dist/client/DbQuery.js

@@ -14,6 +14,13 @@ class DbQuery {
     queryRows(sql) {
         return this.query(sql.toString()).then((res) => res.rows);
     }
+    queryFirstRow(sql) {
+        return this.query(sql.toString()).then(({ rows, rowCount }) => {
+            if (rows.length === 0)
+                throw new Error("Query did not return any rows");
+            return rows[0];
+        });
+    }
     multipleQueryRows(sql) {
         return this.multipleQuery(sql.toString()).then((res) => res.map((item) => item.rows ?? []));
     }

package/dist/client/DbQueryBase.d.ts

@@ -0,0 +1,26 @@
+import type { SqlStatementDataset } from "../sql_gen/mod.ts";
+import { StringLike } 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 type QueryResult = MultipleQueryResult | SingleQueryResult;
+/** @public */
+export interface DbQueryBase {
+    /** 单语句查询，不应查询多语句，否则返回错误值  */
+    query<T = any>(sql: SqlStatementDataset<T>): Promise<QueryRowsResult<T>>;
+    /** 单语句查询，不应查询多语句，否则返回错误值  */
+    query<T = any>(sql: StringLike): Promise<QueryRowsResult<T>>;
+    /** 多语句查询 */
+    multipleQuery<T extends MultipleQueryResult = MultipleQueryResult>(sql: StringLike): Promise<T>;
+}
+//# sourceMappingURL=DbQueryBase.d.ts.map

package/dist/client/interfaces.d.ts

@@ -59,8 +59,10 @@ export interface DbQueryPool extends DbQuery {
     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>>;
+    cursor<T>(sql: StringLike, option?: DbCursorOption): Promise<DbCursor<T>>;
 }
+/** @public */
+export type StringLike = {
+    toString(): string;
+} | string;
 //# sourceMappingURL=interfaces.d.ts.map

package/dist/client/mod.d.ts

@@ -1,5 +1,6 @@
 export * from "./errors.ts";
 export * from "./interfaces.ts";
+export * from "./DbQueryBase.ts";
 export * from "./DbQuery.ts";
 export * from "./DbCursor.ts";
 export * from "./DbPoolConnection.ts";

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

@@ -20,6 +20,8 @@ export declare class DbTable<T extends TableType> {
         [key: string]: string | boolean;
     }>, as?: string): ChainSelect<Record<string, any>>;
     /** 选择单表  */
+    select<R extends {} = Record<string, any>>(columns: Constructable<string | string[]>, as?: string): ChainSelect<R>;
+    /** 选择单表  */
     select<R extends {}>(columns: Constructable<{
         [key in keyof R]: boolean | string;
     } | string | string[]>, as?: string): ChainSelect<R>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asla/yoursql",
-  "version": "0.8.7",
+  "version": "0.8.8",
   "description": "",
   "type": "module",
   "types": "./dist/mod.d.ts",