ts-sql-query - npm Package Compare versions

Comparing version 1.2.0 to 1.3.0

connections/AbstractConnection.d.ts

@@ -17,2 +17,3 @@ import type { SqlBuilder } from "../sqlBuilders/SqlBuilder";
 import { database, tableOrViewRef, type } from "../utils/symbols";
+import { UnwrapPromiseTuple } from "../utils/PromiseProvider";
 export declare abstract class AbstractConnection<DB extends AnyDB> implements IConnection<DB> {
@@ -27,2 +28,4 @@ [database]: DB;
     constructor(queryRunner: QueryRunner, sqlBuilder: SqlBuilder);
+    transaction<P extends Promise<any>[]>(fn: () => [...P]): Promise<UnwrapPromiseTuple<P>>;
+    transaction<T>(fn: () => Promise<T>): Promise<T>;
     beginTransaction(): Promise<void>;
@@ -29,0 +32,0 @@ commit(): Promise<void>;

connections/AbstractConnection.js

@@ -25,2 +25,13 @@ "use strict";
     }
+    transaction(fn) {
+        const source = new Error('Transaction executed at');
+        try {
+            return this.queryRunner.executeInTransaction(fn, this.queryRunner).catch((e) => {
+                throw attachSource_1.attachTransactionSource(new chained_error_1.default(e), source);
+            });
+        }
+        catch (e) {
+            throw new chained_error_1.default(e);
+        }
+    }
     beginTransaction() {
@@ -27,0 +38,0 @@ const source = new Error('Query executed at');

package.json

 {
     "name": "ts-sql-query",
-    "version": "1.2.0",
+    "version": "1.3.0",
     "description": "Type-safe SQL query builder like QueryDSL or JOOQ in Java or Linq in .Net for TypeScript with MariaDB, MySql, Oracle, PostgreSql, Sqlite and SqlServer support.",
@@ -34,5 +34,7 @@ "license": "MIT",
     "scripts": {
+        "generate-prisma": "prisma generate --schema src/examples/prisma/postgresql.prisma; prisma generate --schema src/examples/prisma/mysql.prisma; prisma generate --schema src/examples/prisma/mariadb.prisma; prisma generate --schema src/examples/prisma/sqlite.prisma; prisma generate --schema src/examples/prisma/sqlserver.prisma",
+        "copy-prisma": "cp -R ./src/examples/prisma ./dist/examples/prisma",
         "example": "npm run build && node dist/exampleTests.js",
         "all-examples": "npm run build && sh ./scripts/run-all-examples.sh",
-        "build": "rm -rf dist/*; tsc",
+        "build": "rm -rf dist/*; tsc && npm run copy-prisma",
         "dist": "npm run build && cp LICENSE.md package.json README.md dist && cd dist && rm exampleTests* && rm -Rf examples && npm publish",
@@ -49,2 +51,3 @@ "dist-beta": "npm run build && cp LICENSE.md package.json README.md dist && cd dist && rm exampleTests* && rm -Rf examples && npm publish --tag beta"
     "devDependencies": {
+        "@prisma/client": "^2.22.1",
         "@types/any-db": "^2.1.30",
@@ -79,2 +82,3 @@ "@types/any-db-transaction": "^2.2.30",
         "pg": "^8.5.1",
+        "prisma": "^2.22.1",
         "sqlite": "^4.0.14",
@@ -81,0 +85,0 @@ "sqlite3": "^5.0.0",

queryBuilders/SelectQueryBuilder.d.ts

@@ -39,2 +39,3 @@ import type { SqlBuilder, JoinData, ToSql, SelectData } from "../sqlBuilders/SqlBuilder";
     executeSelectOne(): Promise<any>;
+    __executeSelectMany(source: Error): Promise<any>;
     executeSelectMany(): Promise<any>;
@@ -41,0 +42,0 @@ __executeSelectCount(source: Error): Promise<any>;

queryBuilders/SelectQueryBuilder.js

@@ -137,5 +137,4 @@ "use strict";
     }
-    executeSelectMany() {
+    __executeSelectMany(source) {
         this.query();
-        const source = new Error('Query executed at');
         try {
@@ -169,2 +168,6 @@ if (this.__oneColumn) {
     }
+    executeSelectMany() {
+        const source = new Error('Query executed at');
+        return this.__executeSelectMany(source);
+    }
     __executeSelectCount(source) {
@@ -195,19 +198,24 @@ try {
     executeSelectPage(extras) {
-        let dataPromise;
+        const source = new Error('Query executed at');
+        if (extras && (extras.count !== undefined && extras.count !== null)) {
+            if (extras.data) {
+                return this.__sqlBuilder._queryRunner.createResolvedPromise({ ...extras, data: extras.data, count: extras.count });
+            }
+            return this.__executeSelectMany(source).then((data) => {
+                return { ...extras, data, count: extras.count };
+            });
+        }
         if (extras && extras.data) {
-            dataPromise = this.__sqlBuilder._queryRunner.createResolvedPromise(extras.data);
+            return this.__executeSelectCount(source).then((count) => {
+                return { ...extras, data: extras.data, count };
+            });
         }
-        else {
-            dataPromise = this.executeSelectMany();
-        }
-        const source = new Error('Query executed at');
-        return dataPromise.then((data) => {
-            if (extras && (extras.count !== undefined && extras.count !== null)) {
-                return { ...extras, data, count: extras.count };
-            }
-            else {
-                return this.__executeSelectCount(source).then((count) => {
-                    return { ...extras, data, count };
-                });
-            }
+        const getDataFn = () => {
+            return this.__executeSelectMany(source);
+        };
+        const getCountFn = () => {
+            return this.__executeSelectCount(source);
+        };
+        return this.__sqlBuilder._queryRunner.executeCombined(getDataFn, getCountFn).then(([data, count]) => {
+            return { ...extras, data, count };
         });
@@ -214,0 +222,0 @@ }

queryRunners/AbstractPoolQueryRunner.d.ts

@@ -1,8 +0,6 @@
-import type { QueryRunner, DatabaseType } from "./QueryRunner";
-export declare abstract class AbstractPoolQueryRunner implements QueryRunner {
+import { AbstractQueryRunner } from "./AbstractQueryRunner";
+import type { QueryRunner } from "./QueryRunner";
+export declare abstract class AbstractPoolQueryRunner extends AbstractQueryRunner {
     private currentQueryRunner?;
     private transactionLevel;
-    abstract readonly database: DatabaseType;
-    abstract useDatabase(database: DatabaseType): void;
-    abstract getNativeRunner(): unknown;
     execute<RESULT>(fn: (connection: unknown, transaction?: unknown) => Promise<RESULT>): Promise<RESULT>;
@@ -24,5 +22,2 @@ executeSelectOneRow(query: string, params?: any[]): Promise<any>;
     executeDatabaseSchemaModification(query: string, params?: any[]): Promise<void>;
-    abstract addParam(params: any[], value: any): string;
-    abstract addOutParam(params: any[], name: string): string;
-    abstract createResolvedPromise<RESULT>(result: RESULT): Promise<RESULT>;
     private getQueryRunner;
@@ -29,0 +24,0 @@ private releaseIfNeeded;

queryRunners/AbstractPoolQueryRunner.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractPoolQueryRunner = void 0;
-class AbstractPoolQueryRunner {
+const AbstractQueryRunner_1 = require("./AbstractQueryRunner");
+class AbstractPoolQueryRunner extends AbstractQueryRunner_1.AbstractQueryRunner {
     constructor() {
+        super(...arguments);
         this.transactionLevel = 0;
@@ -7,0 +9,0 @@ }

queryRunners/AnyDBPoolQueryRunner.d.ts

 import type { DatabaseType, QueryRunner } from "./QueryRunner";
 import type { ConnectionPool } from 'any-db';
 import { AbstractPoolQueryRunner } from "./AbstractPoolQueryRunner";
+import { UnwrapPromiseTuple } from "../utils/PromiseProvider";
 export declare class AnyDBPoolQueryRunner extends AbstractPoolQueryRunner {
@@ -14,4 +15,5 @@ readonly database: DatabaseType;
     createResolvedPromise<RESULT>(result: RESULT): Promise<RESULT>;
+    createAllPromise<P extends Promise<any>[]>(promises: [...P]): Promise<UnwrapPromiseTuple<P>>;
     protected createQueryRunner(): Promise<QueryRunner>;
     protected releaseQueryRunner(queryRunner: QueryRunner): void;
 }

queryRunners/AnyDBPoolQueryRunner.js

@@ -83,2 +83,5 @@ "use strict";
     }
+    createAllPromise(promises) {
+        return Promise.all(promises);
+    }
     createQueryRunner() {
@@ -85,0 +88,0 @@ return new Promise((resolve, reject) => {

queryRunners/AnyDBQueryRunner.d.ts

@@ -1,5 +0,7 @@
-import type { QueryRunner, DatabaseType } from "./QueryRunner";
+import type { DatabaseType } from "./QueryRunner";
 import type { Connection, ResultSet } from 'any-db';
 import * as begin from 'any-db-transaction';
-export declare class AnyDBQueryRunner implements QueryRunner {
+import { AbstractQueryRunner } from "./AbstractQueryRunner";
+import { UnwrapPromiseTuple } from "../utils/PromiseProvider";
+export declare class AnyDBQueryRunner extends AbstractQueryRunner {
     readonly database: DatabaseType;
@@ -30,3 +32,4 @@ readonly connection: Connection;
     createResolvedPromise<RESULT>(result: RESULT): Promise<RESULT>;
+    createAllPromise<P extends Promise<any>[]>(promises: [...P]): Promise<UnwrapPromiseTuple<P>>;
     protected query(query: string, params?: any[]): Promise<ResultSet>;
 }

queryRunners/AnyDBQueryRunner.js

@@ -5,4 +5,6 @@ "use strict";
 const begin = require("any-db-transaction");
-class AnyDBQueryRunner {
+const AbstractQueryRunner_1 = require("./AbstractQueryRunner");
+class AnyDBQueryRunner extends AbstractQueryRunner_1.AbstractQueryRunner {
     constructor(connection) {
+        super();
         this.connection = connection;
@@ -230,2 +232,5 @@ switch (this.connection.adapter.name) {
     }
+    createAllPromise(promises) {
+        return Promise.all(promises);
+    }
     query(query, params) {
@@ -232,0 +237,0 @@ let queryParams = params;

queryRunners/BetterSqlite3QueryRunner.d.ts

@@ -1,8 +0,9 @@
-import type { QueryRunner, DatabaseType } from "./QueryRunner";
+import type { DatabaseType } from "./QueryRunner";
 import type { Database } from 'better-sqlite3';
-import type { PromiseProvider } from "../utils/PromiseProvider";
+import type { PromiseProvider, UnwrapPromiseTuple } from "../utils/PromiseProvider";
+import { AbstractQueryRunner } from "./AbstractQueryRunner";
 export interface BetterSqlite3QueryRunnerConfig {
     promise?: PromiseProvider;
 }
-export declare class BetterSqlite3QueryRunner implements QueryRunner {
+export declare class BetterSqlite3QueryRunner extends AbstractQueryRunner {
     readonly database: DatabaseType;
@@ -33,2 +34,3 @@ readonly connection: Database;
     createResolvedPromise<RESULT>(result: RESULT): Promise<RESULT>;
+    createAllPromise<P extends Promise<any>[]>(promises: [...P]): Promise<UnwrapPromiseTuple<P>>;
 }

queryRunners/BetterSqlite3QueryRunner.js

@@ -5,4 +5,6 @@ "use strict";
 const better_sqlite3_1 = require("better-sqlite3");
-class BetterSqlite3QueryRunner {
+const AbstractQueryRunner_1 = require("./AbstractQueryRunner");
+class BetterSqlite3QueryRunner extends AbstractQueryRunner_1.AbstractQueryRunner {
     constructor(connection, config) {
+        super();
         this.connection = connection;
@@ -202,2 +204,5 @@ this.database = 'sqlite';
     }
+    createAllPromise(promises) {
+        return this.promise.all(promises);
+    }
 }
@@ -204,0 +209,0 @@ exports.BetterSqlite3QueryRunner = BetterSqlite3QueryRunner;

queryRunners/ChainedQueryRunner.d.ts

@@ -0,1 +1,2 @@
+import { UnwrapPromiseTuple } from "../utils/PromiseProvider";
 import type { QueryRunner, DatabaseType } from "./QueryRunner";
@@ -23,2 +24,5 @@ export declare class ChainedQueryRunner<T extends QueryRunner> implements QueryRunner {
     executeRollback(): Promise<void>;
+    executeInTransaction<P extends Promise<any>[]>(fn: () => [...P], outermostQueryRunner: QueryRunner): Promise<UnwrapPromiseTuple<P>>;
+    executeInTransaction<T>(fn: () => Promise<T>, outermostQueryRunner: QueryRunner): Promise<T>;
+    executeInTransaction(fn: () => Promise<any>[] | Promise<any>, outermostQueryRunner: QueryRunner): Promise<any>;
     executeDatabaseSchemaModification(query: string, params?: any[]): Promise<void>;
@@ -28,2 +32,3 @@ addParam(params: any[], value: any): string;
     createResolvedPromise<RESULT>(result: RESULT): Promise<RESULT>;
+    executeCombined<R1, R2>(fn1: () => Promise<R1>, fn2: () => Promise<R2>): Promise<[R1, R2]>;
 }

queryRunners/ChainedQueryRunner.js

@@ -62,2 +62,5 @@ "use strict";
     }
+    executeInTransaction(fn, outermostQueryRunner) {
+        return this.queryRunner.executeInTransaction(fn, outermostQueryRunner);
+    }
     executeDatabaseSchemaModification(query, params = []) {
@@ -75,4 +78,7 @@ return this.queryRunner.executeDatabaseSchemaModification(query, params);
     }
+    executeCombined(fn1, fn2) {
+        return this.queryRunner.executeCombined(fn1, fn2);
+    }
 }
 exports.ChainedQueryRunner = ChainedQueryRunner;
 //# sourceMappingURL=ChainedQueryRunner.js.map

queryRunners/ConsoleLogNoopQueryRunner.d.ts

@@ -1,3 +0,4 @@
-import type { PromiseProvider } from "../utils/PromiseProvider";
-import type { QueryRunner, DatabaseType } from "./QueryRunner";
+import type { PromiseProvider, UnwrapPromiseTuple } from "../utils/PromiseProvider";
+import { AbstractQueryRunner } from "./AbstractQueryRunner";
+import type { DatabaseType } from "./QueryRunner";
 export interface ConsoleLogNoopQueryRunnerConfig {
@@ -7,3 +8,3 @@ database?: DatabaseType;
 }
-export declare class ConsoleLogNoopQueryRunner implements QueryRunner {
+export declare class ConsoleLogNoopQueryRunner extends AbstractQueryRunner {
     readonly database: DatabaseType;
@@ -33,2 +34,3 @@ readonly promise: PromiseProvider;
     createResolvedPromise<RESULT>(result: RESULT): Promise<RESULT>;
+    createAllPromise<P extends Promise<any>[]>(promises: [...P]): Promise<UnwrapPromiseTuple<P>>;
 }

queryRunners/ConsoleLogNoopQueryRunner.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConsoleLogNoopQueryRunner = void 0;
-class ConsoleLogNoopQueryRunner {
+const AbstractQueryRunner_1 = require("./AbstractQueryRunner");
+class ConsoleLogNoopQueryRunner extends AbstractQueryRunner_1.AbstractQueryRunner {
     constructor(databaseOrConfig = 'noopDB') {
+        super();
         if (typeof databaseOrConfig === 'string') {
@@ -121,4 +123,7 @@ databaseOrConfig = { database: databaseOrConfig };
     }
+    createAllPromise(promises) {
+        return this.promise.all(promises);
+    }
 }
 exports.ConsoleLogNoopQueryRunner = ConsoleLogNoopQueryRunner;
 //# sourceMappingURL=ConsoleLogNoopQueryRunner.js.map

queryRunners/LoopBackQueryRunner.d.ts

 import type { DatabaseType, QueryRunner } from "./QueryRunner";
 import type { DataSource, Transaction } from 'loopback-datasource-juggler';
+import { AbstractQueryRunner } from "./AbstractQueryRunner";
+import { UnwrapPromiseTuple } from "../utils/PromiseProvider";
 export declare function createLoopBackQueryRunner(datasource: DataSource, transaction?: Transaction): LoopbackQueryRunner;
@@ -10,3 +12,3 @@ export interface LoopbackQueryRunner extends QueryRunner {
 }
-export declare abstract class LoopBackAbstractQueryRunner implements LoopbackQueryRunner {
+export declare abstract class LoopBackAbstractQueryRunner extends AbstractQueryRunner implements LoopbackQueryRunner {
     readonly database: DatabaseType;
@@ -38,2 +40,3 @@ readonly datasource: DataSource;
     createResolvedPromise<RESULT>(result: RESULT): Promise<RESULT>;
+    createAllPromise<P extends Promise<any>[]>(promises: [...P]): Promise<UnwrapPromiseTuple<P>>;
     protected query(query: string, params?: any[]): Promise<any>;
@@ -40,0 +43,0 @@ }

queryRunners/LoopBackQueryRunner.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LoopBackSqlServerQueryRunner = exports.LoopBackPostgreSqlQueryRunner = exports.LoopBackOracleQueryRunner = exports.LoopBackMySqlQueryRunner = exports.LoopBackAbstractQueryRunner = exports.createLoopBackQueryRunner = void 0;
+const AbstractQueryRunner_1 = require("./AbstractQueryRunner");
 function createLoopBackQueryRunner(datasource, transaction) {
@@ -25,4 +26,5 @@ const connector = datasource.connector;
 exports.createLoopBackQueryRunner = createLoopBackQueryRunner;
-class LoopBackAbstractQueryRunner {
+class LoopBackAbstractQueryRunner extends AbstractQueryRunner_1.AbstractQueryRunner {
     constructor(database, datasource, transaction) {
+        super();
         this.database = database;
@@ -133,2 +135,5 @@ this.datasource = datasource;
     }
+    createAllPromise(promises) {
+        return Promise.all(promises);
+    }
     query(query, params) {
@@ -135,0 +140,0 @@ return this.datasource.execute(query, params, { transaction: this.transaction });

queryRunners/MariaDBPoolQueryRunner.d.ts

 import type { DatabaseType, QueryRunner } from "./QueryRunner";
 import type { Pool } from 'mariadb';
 import { AbstractPoolQueryRunner } from "./AbstractPoolQueryRunner";
+import { UnwrapPromiseTuple } from "../utils/PromiseProvider";
 export declare class MariaDBPoolQueryRunner extends AbstractPoolQueryRunner {
@@ -14,4 +15,5 @@ readonly database: DatabaseType;
     createResolvedPromise<RESULT>(result: RESULT): Promise<RESULT>;
+    createAllPromise<P extends Promise<any>[]>(promises: [...P]): Promise<UnwrapPromiseTuple<P>>;
     protected createQueryRunner(): Promise<QueryRunner>;
     protected releaseQueryRunner(queryRunner: QueryRunner): void;
 }

queryRunners/MariaDBPoolQueryRunner.js

@@ -37,2 +37,5 @@ "use strict";
     }
+    createAllPromise(promises) {
+        return Promise.all(promises);
+    }
     createQueryRunner() {
@@ -39,0 +42,0 @@ return this.pool.getConnection().then(mariaDBConnection => new MariaDBQueryRunner_1.MariaDBQueryRunner(mariaDBConnection, this.database));

queryRunners/MariaDBQueryRunner.d.ts

@@ -1,4 +0,6 @@
-import type { QueryRunner, DatabaseType } from "./QueryRunner";
+import type { DatabaseType } from "./QueryRunner";
 import type { Connection } from 'mariadb';
-export declare class MariaDBQueryRunner implements QueryRunner {
+import { AbstractQueryRunner } from "./AbstractQueryRunner";
+import { UnwrapPromiseTuple } from "../utils/PromiseProvider";
+export declare class MariaDBQueryRunner extends AbstractQueryRunner {
     readonly database: DatabaseType;
@@ -28,2 +30,3 @@ readonly connection: Connection;
     createResolvedPromise<RESULT>(result: RESULT): Promise<RESULT>;
+    createAllPromise<P extends Promise<any>[]>(promises: [...P]): Promise<UnwrapPromiseTuple<P>>;
 }

queryRunners/MariaDBQueryRunner.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MariaDBQueryRunner = void 0;
-class MariaDBQueryRunner {
+const AbstractQueryRunner_1 = require("./AbstractQueryRunner");
+class MariaDBQueryRunner extends AbstractQueryRunner_1.AbstractQueryRunner {
     constructor(connection, database = 'mariaDB') {
+        super();
         this.connection = connection;
@@ -117,4 +119,7 @@ this.database = database;
     }
+    createAllPromise(promises) {
+        return Promise.all(promises);
+    }
 }
 exports.MariaDBQueryRunner = MariaDBQueryRunner;
 //# sourceMappingURL=MariaDBQueryRunner.js.map

queryRunners/MockQueryRunner.d.ts

@@ -1,3 +0,4 @@
-import type { PromiseProvider } from "../utils/PromiseProvider";
-import type { QueryRunner, DatabaseType } from "./QueryRunner";
+import type { PromiseProvider, UnwrapPromiseTuple } from "../utils/PromiseProvider";
+import { AbstractQueryRunner } from "./AbstractQueryRunner";
+import type { DatabaseType } from "./QueryRunner";
 export declare type QueryType = 'selectOneRow' | 'selectManyRows' | 'selectOneColumnOneRow' | 'selectOneColumnManyRows' | 'insert' | 'insertReturningLastInsertedId' | 'insertReturningMultipleLastInsertedId' | 'update' | 'delete' | 'executeProcedure' | 'executeFunction' | 'beginTransaction' | 'commit' | 'rollback' | 'executeDatabaseSchemaModification';
@@ -9,3 +10,3 @@ export declare type QueryExecutor = (type: QueryType, query: string, params: any[], index: number) => any;
 }
-export declare class MockQueryRunner implements QueryRunner {
+export declare class MockQueryRunner extends AbstractQueryRunner {
     private count;
@@ -37,2 +38,3 @@ readonly queryExecutor: QueryExecutor;
     createResolvedPromise<RESULT>(result: RESULT): Promise<RESULT>;
+    createAllPromise<P extends Promise<any>[]>(promises: [...P]): Promise<UnwrapPromiseTuple<P>>;
 }

queryRunners/MockQueryRunner.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MockQueryRunner = void 0;
-class MockQueryRunner {
+const AbstractQueryRunner_1 = require("./AbstractQueryRunner");
+class MockQueryRunner extends AbstractQueryRunner_1.AbstractQueryRunner {
     constructor(queryExecutor, databaseOrConfig = 'noopDB') {
+        super();
         this.count = 0;
@@ -183,4 +185,7 @@ this.queryExecutor = queryExecutor;
     }
+    createAllPromise(promises) {
+        return this.promise.all(promises);
+    }
 }
 exports.MockQueryRunner = MockQueryRunner;
 //# sourceMappingURL=MockQueryRunner.js.map

queryRunners/MsNodeSqlV8QueryRunner.d.ts

@@ -1,2 +0,4 @@
-import type { QueryRunner, DatabaseType } from "./QueryRunner";
+import { UnwrapPromiseTuple } from "../utils/PromiseProvider";
+import { AbstractQueryRunner } from "./AbstractQueryRunner";
+import type { DatabaseType } from "./QueryRunner";
 export interface Connection {
@@ -28,3 +30,3 @@ query(sql: string, params?: any[], cb?: QueryCb): Query;
 }
-export declare class MsNodeSqlV8QueryRunner<CONNECTION extends Connection> implements QueryRunner {
+export declare class MsNodeSqlV8QueryRunner<CONNECTION extends Connection> extends AbstractQueryRunner {
     readonly database: DatabaseType;
@@ -54,2 +56,3 @@ readonly connection: CONNECTION;
     createResolvedPromise<RESULT>(result: RESULT): Promise<RESULT>;
+    createAllPromise<P extends Promise<any>[]>(promises: [...P]): Promise<UnwrapPromiseTuple<P>>;
 }

queryRunners/MsNodeSqlV8QueryRunner.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MsNodeSqlV8QueryRunner = void 0;
-class MsNodeSqlV8QueryRunner {
+const AbstractQueryRunner_1 = require("./AbstractQueryRunner");
+class MsNodeSqlV8QueryRunner extends AbstractQueryRunner_1.AbstractQueryRunner {
     constructor(connection) {
+        super();
         this.connection = connection;
@@ -297,4 +299,7 @@ this.database = 'sqlServer';
     }
+    createAllPromise(promises) {
+        return Promise.all(promises);
+    }
 }
 exports.MsNodeSqlV8QueryRunner = MsNodeSqlV8QueryRunner;
 //# sourceMappingURL=MsNodeSqlV8QueryRunner.js.map

queryRunners/MssqlPoolPromiseQueryRunner.d.ts

 import type { DatabaseType, QueryRunner } from "./QueryRunner";
 import type { ConnectionPool } from 'mssql';
 import { AbstractPoolQueryRunner } from "./AbstractPoolQueryRunner";
+import { UnwrapPromiseTuple } from "../utils/PromiseProvider";
 export declare class MssqlPoolPromiseQueryRunner extends AbstractPoolQueryRunner {
@@ -13,4 +14,5 @@ readonly database: DatabaseType;
     createResolvedPromise<RESULT>(result: RESULT): Promise<RESULT>;
+    createAllPromise<P extends Promise<any>[]>(promises: [...P]): Promise<UnwrapPromiseTuple<P>>;
     protected createQueryRunner(): Promise<QueryRunner>;
     protected releaseQueryRunner(_queryRunner: QueryRunner): void;
 }

queryRunners/MssqlPoolPromiseQueryRunner.js

@@ -31,2 +31,5 @@ "use strict";
     }
+    createAllPromise(promises) {
+        return Promise.all(promises);
+    }
     createQueryRunner() {
@@ -33,0 +36,0 @@ return this.promisePool.then(pool => new MssqlPoolQueryRunner_1.MssqlPoolQueryRunner(pool));

queryRunners/MssqlPoolQueryRunner.d.ts

@@ -1,4 +0,6 @@
-import type { QueryRunner, DatabaseType } from "./QueryRunner";
+import type { DatabaseType } from "./QueryRunner";
 import type { ConnectionPool, ISqlTypeFactory, Transaction, Request } from 'mssql';
-export declare class MssqlPoolQueryRunner implements QueryRunner {
+import { UnwrapPromiseTuple } from "../utils/PromiseProvider";
+import { AbstractQueryRunner } from "./AbstractQueryRunner";
+export declare class MssqlPoolQueryRunner extends AbstractQueryRunner {
     readonly database: DatabaseType;
@@ -29,2 +31,3 @@ readonly pool: ConnectionPool;
     createResolvedPromise<RESULT>(result: RESULT): Promise<RESULT>;
+    createAllPromise<P extends Promise<any>[]>(promises: [...P]): Promise<UnwrapPromiseTuple<P>>;
     protected request(): Request;
@@ -31,0 +34,0 @@ protected predefinedTypes: {

queryRunners/MssqlPoolQueryRunner.js

@@ -5,4 +5,6 @@ "use strict";
 const mssql_1 = require("mssql");
-class MssqlPoolQueryRunner {
+const AbstractQueryRunner_1 = require("./AbstractQueryRunner");
+class MssqlPoolQueryRunner extends AbstractQueryRunner_1.AbstractQueryRunner {
     constructor(pool) {
+        super();
         this.predefinedTypes = {
@@ -241,2 +243,5 @@ boolean: mssql_1.TYPES.Bit,
     }
+    createAllPromise(promises) {
+        return Promise.all(promises);
+    }
     request() {
@@ -243,0 +248,0 @@ if (this.transaction) {

queryRunners/MySql2PoolQueryRunner.d.ts

 import type { DatabaseType, QueryRunner } from "./QueryRunner";
 import type { Pool } from "mysql2";
 import { AbstractPoolQueryRunner } from "./AbstractPoolQueryRunner";
+import { UnwrapPromiseTuple } from "../utils/PromiseProvider";
 export declare class MySql2PoolQueryRunner extends AbstractPoolQueryRunner {
@@ -14,4 +15,5 @@ readonly database: DatabaseType;
     createResolvedPromise<RESULT>(result: RESULT): Promise<RESULT>;
+    createAllPromise<P extends Promise<any>[]>(promises: [...P]): Promise<UnwrapPromiseTuple<P>>;
     protected createQueryRunner(): Promise<QueryRunner>;
     protected releaseQueryRunner(queryRunner: QueryRunner): void;
 }

queryRunners/MySql2PoolQueryRunner.js

@@ -37,2 +37,5 @@ "use strict";
     }
+    createAllPromise(promises) {
+        return Promise.all(promises);
+    }
     createQueryRunner() {
@@ -39,0 +42,0 @@ return new Promise((resolve, reject) => {

queryRunners/MySql2QueryRunner.d.ts

@@ -1,4 +0,6 @@
-import type { QueryRunner, DatabaseType } from "./QueryRunner";
+import type { DatabaseType } from "./QueryRunner";
 import type { Connection } from "mysql2";
-export declare class MySql2QueryRunner implements QueryRunner {
+import { AbstractQueryRunner } from "./AbstractQueryRunner";
+import { UnwrapPromiseTuple } from "../utils/PromiseProvider";
+export declare class MySql2QueryRunner extends AbstractQueryRunner {
     readonly database: DatabaseType;
@@ -28,2 +30,3 @@ readonly connection: Connection;
     createResolvedPromise<RESULT>(result: RESULT): Promise<RESULT>;
+    createAllPromise<P extends Promise<any>[]>(promises: [...P]): Promise<UnwrapPromiseTuple<P>>;
 }

queryRunners/MySql2QueryRunner.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MySql2QueryRunner = void 0;
-class MySql2QueryRunner {
+const AbstractQueryRunner_1 = require("./AbstractQueryRunner");
+class MySql2QueryRunner extends AbstractQueryRunner_1.AbstractQueryRunner {
     constructor(connection, database = 'mySql') {
+        super();
         this.connection = connection;
@@ -247,4 +249,7 @@ this.database = database;
     }
+    createAllPromise(promises) {
+        return Promise.all(promises);
+    }
 }
 exports.MySql2QueryRunner = MySql2QueryRunner;
 //# sourceMappingURL=MySql2QueryRunner.js.map

queryRunners/MySqlPoolQueryRunner.d.ts

 import type { DatabaseType, QueryRunner } from "./QueryRunner";
 import type { Pool } from "mysql";
 import { AbstractPoolQueryRunner } from "./AbstractPoolQueryRunner";
+import { UnwrapPromiseTuple } from "../utils/PromiseProvider";
 export declare class MySqlPoolQueryRunner extends AbstractPoolQueryRunner {
@@ -14,4 +15,5 @@ readonly database: DatabaseType;
     createResolvedPromise<RESULT>(result: RESULT): Promise<RESULT>;
+    createAllPromise<P extends Promise<any>[]>(promises: [...P]): Promise<UnwrapPromiseTuple<P>>;
     protected createQueryRunner(): Promise<QueryRunner>;
     protected releaseQueryRunner(queryRunner: QueryRunner): void;
 }

queryRunners/MySqlPoolQueryRunner.js

@@ -37,2 +37,5 @@ "use strict";
     }
+    createAllPromise(promises) {
+        return Promise.all(promises);
+    }
     createQueryRunner() {
@@ -39,0 +42,0 @@ return new Promise((resolve, reject) => {

queryRunners/MySqlQueryRunner.d.ts

@@ -1,4 +0,6 @@
-import type { QueryRunner, DatabaseType } from "./QueryRunner";
+import type { DatabaseType } from "./QueryRunner";
 import type { Connection } from "mysql";
-export declare class MySqlQueryRunner implements QueryRunner {
+import { AbstractQueryRunner } from "./AbstractQueryRunner";
+import { UnwrapPromiseTuple } from "../utils/PromiseProvider";
+export declare class MySqlQueryRunner extends AbstractQueryRunner {
     readonly database: DatabaseType;
@@ -28,2 +30,3 @@ readonly connection: Connection;
     createResolvedPromise<RESULT>(result: RESULT): Promise<RESULT>;
+    createAllPromise<P extends Promise<any>[]>(promises: [...P]): Promise<UnwrapPromiseTuple<P>>;
 }

queryRunners/MySqlQueryRunner.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MySqlQueryRunner = void 0;
-class MySqlQueryRunner {
+const AbstractQueryRunner_1 = require("./AbstractQueryRunner");
+class MySqlQueryRunner extends AbstractQueryRunner_1.AbstractQueryRunner {
     constructor(connection, database = 'mySql') {
+        super();
         this.connection = connection;
@@ -247,4 +249,7 @@ this.database = database;
     }
+    createAllPromise(promises) {
+        return Promise.all(promises);
+    }
 }
 exports.MySqlQueryRunner = MySqlQueryRunner;
 //# sourceMappingURL=MySqlQueryRunner.js.map

queryRunners/NoopQueryRunner.d.ts

@@ -1,3 +0,4 @@
-import type { PromiseProvider } from "../utils/PromiseProvider";
-import type { QueryRunner, DatabaseType } from "./QueryRunner";
+import type { PromiseProvider, UnwrapPromiseTuple } from "../utils/PromiseProvider";
+import { AbstractQueryRunner } from "./AbstractQueryRunner";
+import type { DatabaseType } from "./QueryRunner";
 export interface NoopQueryRunnerConfig {
@@ -7,3 +8,3 @@ database?: DatabaseType;
 }
-export declare class NoopQueryRunner implements QueryRunner {
+export declare class NoopQueryRunner extends AbstractQueryRunner {
     readonly database: DatabaseType;
@@ -33,2 +34,3 @@ readonly promise: PromiseProvider;
     createResolvedPromise<RESULT>(result: RESULT): Promise<RESULT>;
+    createAllPromise<P extends Promise<any>[]>(promises: [...P]): Promise<UnwrapPromiseTuple<P>>;
 }

queryRunners/NoopQueryRunner.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NoopQueryRunner = void 0;
-class NoopQueryRunner {
+const AbstractQueryRunner_1 = require("./AbstractQueryRunner");
+class NoopQueryRunner extends AbstractQueryRunner_1.AbstractQueryRunner {
     constructor(databaseOrConfig = 'noopDB') {
+        super();
         if (typeof databaseOrConfig === 'string') {
@@ -106,4 +108,7 @@ databaseOrConfig = { database: databaseOrConfig };
     }
+    createAllPromise(promises) {
+        return this.promise.all(promises);
+    }
 }
 exports.NoopQueryRunner = NoopQueryRunner;
 //# sourceMappingURL=NoopQueryRunner.js.map

queryRunners/OracleDBPoolPromiseQueryRunner.d.ts

 import type { DatabaseType, QueryRunner } from "./QueryRunner";
 import type { Pool } from 'oracledb';
 import { AbstractPoolQueryRunner } from "./AbstractPoolQueryRunner";
+import { UnwrapPromiseTuple } from "../utils/PromiseProvider";
 export declare class OracleDBPoolPromiseQueryRunner extends AbstractPoolQueryRunner {
@@ -13,4 +14,5 @@ readonly database: DatabaseType;
     createResolvedPromise<RESULT>(result: RESULT): Promise<RESULT>;
+    createAllPromise<P extends Promise<any>[]>(promises: [...P]): Promise<UnwrapPromiseTuple<P>>;
     protected createQueryRunner(): Promise<QueryRunner>;
     protected releaseQueryRunner(queryRunner: QueryRunner): void;
 }

queryRunners/OracleDBPoolPromiseQueryRunner.js

@@ -39,2 +39,5 @@ "use strict";
     }
+    createAllPromise(promises) {
+        return Promise.all(promises);
+    }
     createQueryRunner() {
@@ -41,0 +44,0 @@ return this.promisePool.then(pool => pool.getConnection()).then(connection => new OracleDBQueryRunner_1.OracleDBQueryRunner(connection));

queryRunners/OracleDBPoolQueryRunner.d.ts

 import type { DatabaseType, QueryRunner } from "./QueryRunner";
 import type { Pool } from 'oracledb';
 import { AbstractPoolQueryRunner } from "./AbstractPoolQueryRunner";
+import { UnwrapPromiseTuple } from "../utils/PromiseProvider";
 export declare class OracleDBPoolQueryRunner extends AbstractPoolQueryRunner {
@@ -13,4 +14,5 @@ readonly database: DatabaseType;
     createResolvedPromise<RESULT>(result: RESULT): Promise<RESULT>;
+    createAllPromise<P extends Promise<any>[]>(promises: [...P]): Promise<UnwrapPromiseTuple<P>>;
     protected createQueryRunner(): Promise<QueryRunner>;
     protected releaseQueryRunner(queryRunner: QueryRunner): void;
 }

queryRunners/OracleDBPoolQueryRunner.js

@@ -39,2 +39,5 @@ "use strict";
     }
+    createAllPromise(promises) {
+        return Promise.all(promises);
+    }
     createQueryRunner() {
@@ -41,0 +44,0 @@ return this.pool.getConnection().then(connection => new OracleDBQueryRunner_1.OracleDBQueryRunner(connection));

queryRunners/OracleDBQueryRunner.d.ts

@@ -1,4 +0,6 @@
-import type { QueryRunner, DatabaseType } from "./QueryRunner";
+import type { DatabaseType } from "./QueryRunner";
 import type { Connection } from 'oracledb';
-export declare class OracleDBQueryRunner implements QueryRunner {
+import { AbstractQueryRunner } from "./AbstractQueryRunner";
+import { UnwrapPromiseTuple } from "../utils/PromiseProvider";
+export declare class OracleDBQueryRunner extends AbstractQueryRunner {
     readonly database: DatabaseType;
@@ -28,2 +30,3 @@ readonly connection: Connection;
     createResolvedPromise<RESULT>(result: RESULT): Promise<RESULT>;
+    createAllPromise<P extends Promise<any>[]>(promises: [...P]): Promise<UnwrapPromiseTuple<P>>;
 }

queryRunners/OracleDBQueryRunner.js

@@ -5,4 +5,6 @@ "use strict";
 const oracledb_1 = require("oracledb");
-class OracleDBQueryRunner {
+const AbstractQueryRunner_1 = require("./AbstractQueryRunner");
+class OracleDBQueryRunner extends AbstractQueryRunner_1.AbstractQueryRunner {
     constructor(connection) {
+        super();
         this.connection = connection;
@@ -162,2 +164,5 @@ this.database = 'oracle';
     }
+    createAllPromise(promises) {
+        return Promise.all(promises);
+    }
 }
@@ -164,0 +169,0 @@ exports.OracleDBQueryRunner = OracleDBQueryRunner;

queryRunners/PgPoolQueryRunner.d.ts

 import type { DatabaseType, QueryRunner } from "./QueryRunner";
 import type { Pool } from 'pg';
 import { AbstractPoolQueryRunner } from "./AbstractPoolQueryRunner";
+import { UnwrapPromiseTuple } from "../utils/PromiseProvider";
 export declare class PgPoolQueryRunner extends AbstractPoolQueryRunner {
@@ -13,4 +14,5 @@ readonly database: DatabaseType;
     createResolvedPromise<RESULT>(result: RESULT): Promise<RESULT>;
+    createAllPromise<P extends Promise<any>[]>(promises: [...P]): Promise<UnwrapPromiseTuple<P>>;
     protected createQueryRunner(): Promise<QueryRunner>;
     protected releaseQueryRunner(queryRunner: QueryRunner): void;
 }

queryRunners/PgPoolQueryRunner.js

@@ -30,2 +30,5 @@ "use strict";
     }
+    createAllPromise(promises) {
+        return Promise.all(promises);
+    }
     createQueryRunner() {
@@ -32,0 +35,0 @@ return this.pool.connect().then(connection => new PgQueryRunner_1.PgQueryRunner(connection));

queryRunners/PgQueryRunner.d.ts

@@ -1,4 +0,6 @@
-import type { QueryRunner, DatabaseType } from "./QueryRunner";
+import type { DatabaseType } from "./QueryRunner";
 import type { ClientBase } from 'pg';
-export declare class PgQueryRunner implements QueryRunner {
+import { AbstractQueryRunner } from "./AbstractQueryRunner";
+import { UnwrapPromiseTuple } from "../utils/PromiseProvider";
+export declare class PgQueryRunner extends AbstractQueryRunner {
     readonly database: DatabaseType;
@@ -28,2 +30,3 @@ readonly connection: ClientBase;
     createResolvedPromise<RESULT>(result: RESULT): Promise<RESULT>;
+    createAllPromise<P extends Promise<any>[]>(promises: [...P]): Promise<UnwrapPromiseTuple<P>>;
 }

queryRunners/PgQueryRunner.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PgQueryRunner = void 0;
-class PgQueryRunner {
+const AbstractQueryRunner_1 = require("./AbstractQueryRunner");
+class PgQueryRunner extends AbstractQueryRunner_1.AbstractQueryRunner {
     constructor(connection) {
+        super();
         this.connection = connection;
@@ -134,4 +136,7 @@ this.database = 'postgreSql';
     }
+    createAllPromise(promises) {
+        return Promise.all(promises);
+    }
 }
 exports.PgQueryRunner = PgQueryRunner;
 //# sourceMappingURL=PgQueryRunner.js.map

queryRunners/QueryRunner.d.ts

@@ -0,1 +1,2 @@
+import { UnwrapPromiseTuple } from "../utils/PromiseProvider";
 export interface QueryRunner {
@@ -20,2 +21,5 @@ readonly database: DatabaseType;
     executeRollback(): Promise<void>;
+    executeInTransaction<P extends Promise<any>[]>(fn: () => [...P], outermostQueryRunner: QueryRunner): Promise<UnwrapPromiseTuple<P>>;
+    executeInTransaction<T>(fn: () => Promise<T>, outermostQueryRunner: QueryRunner): Promise<T>;
+    executeInTransaction(fn: () => Promise<any>[] | Promise<any>, outermostQueryRunner: QueryRunner): Promise<any>;
     executeDatabaseSchemaModification(query: string, params?: any[]): Promise<void>;
@@ -25,3 +29,4 @@ addParam(params: any[], value: any): string;
     createResolvedPromise<RESULT>(result: RESULT): Promise<RESULT>;
+    executeCombined<R1, R2>(fn1: () => Promise<R1>, fn2: () => Promise<R2>): Promise<[R1, R2]>;
 }
 export declare type DatabaseType = 'mariaDB' | 'mySql' | 'noopDB' | 'oracle' | 'postgreSql' | 'sqlite' | 'sqlServer';

queryRunners/Sqlite3QueryRunner.d.ts

 /// <reference types="./vendor-typings/sqlite3" />
-import type { QueryRunner, DatabaseType } from "./QueryRunner";
+import type { DatabaseType } from "./QueryRunner";
 import type { Database } from 'sqlite3';
-export declare class Sqlite3QueryRunner implements QueryRunner {
+import { AbstractQueryRunner } from "./AbstractQueryRunner";
+import { UnwrapPromiseTuple } from "../utils/PromiseProvider";
+export declare class Sqlite3QueryRunner extends AbstractQueryRunner {
     readonly database: DatabaseType;
@@ -29,2 +31,3 @@ readonly connection: Database;
     createResolvedPromise<RESULT>(result: RESULT): Promise<RESULT>;
+    createAllPromise<P extends Promise<any>[]>(promises: [...P]): Promise<UnwrapPromiseTuple<P>>;
 }

queryRunners/Sqlite3QueryRunner.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Sqlite3QueryRunner = void 0;
-class Sqlite3QueryRunner {
+const AbstractQueryRunner_1 = require("./AbstractQueryRunner");
+class Sqlite3QueryRunner extends AbstractQueryRunner_1.AbstractQueryRunner {
     constructor(connection) {
+        super();
         this.connection = connection;
@@ -243,4 +245,7 @@ this.database = 'sqlite';
     }
+    createAllPromise(promises) {
+        return Promise.all(promises);
+    }
 }
 exports.Sqlite3QueryRunner = Sqlite3QueryRunner;
 //# sourceMappingURL=Sqlite3QueryRunner.js.map

queryRunners/SqliteQueryRunner.d.ts

@@ -1,4 +0,6 @@
-import type { QueryRunner, DatabaseType } from "./QueryRunner";
+import type { DatabaseType } from "./QueryRunner";
 import type { Database } from 'sqlite';
-export declare class SqliteQueryRunner implements QueryRunner {
+import { UnwrapPromiseTuple } from "../utils/PromiseProvider";
+import { AbstractQueryRunner } from "./AbstractQueryRunner";
+export declare class SqliteQueryRunner extends AbstractQueryRunner {
     readonly database: DatabaseType;
@@ -28,2 +30,3 @@ readonly connection: Database;
     createResolvedPromise<RESULT>(result: RESULT): Promise<RESULT>;
+    createAllPromise<P extends Promise<any>[]>(promises: [...P]): Promise<UnwrapPromiseTuple<P>>;
 }

queryRunners/SqliteQueryRunner.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SqliteQueryRunner = void 0;
-class SqliteQueryRunner {
+const AbstractQueryRunner_1 = require("./AbstractQueryRunner");
+class SqliteQueryRunner extends AbstractQueryRunner_1.AbstractQueryRunner {
     constructor(connection) {
+        super();
         this.connection = connection;
@@ -114,4 +116,7 @@ this.database = 'sqlite';
     }
+    createAllPromise(promises) {
+        return Promise.all(promises);
+    }
 }
 exports.SqliteQueryRunner = SqliteQueryRunner;
 //# sourceMappingURL=SqliteQueryRunner.js.map

queryRunners/TediousPoolQueryRunner.d.ts

 import type { DatabaseType, QueryRunner } from "./QueryRunner";
 import type * as ConnectionPool from 'tedious-connection-pool';
 import { AbstractPoolQueryRunner } from "./AbstractPoolQueryRunner";
+import { UnwrapPromiseTuple } from "../utils/PromiseProvider";
 export declare class TediousPoolQueryRunner extends AbstractPoolQueryRunner {
@@ -13,4 +14,5 @@ readonly database: DatabaseType;
     createResolvedPromise<RESULT>(result: RESULT): Promise<RESULT>;
+    createAllPromise<P extends Promise<any>[]>(promises: [...P]): Promise<UnwrapPromiseTuple<P>>;
     protected createQueryRunner(): Promise<QueryRunner>;
     protected releaseQueryRunner(queryRunner: QueryRunner): void;
 }

queryRunners/TediousPoolQueryRunner.js

@@ -31,2 +31,5 @@ "use strict";
     }
+    createAllPromise(promises) {
+        return Promise.all(promises);
+    }
     createQueryRunner() {
@@ -33,0 +36,0 @@ return new Promise((resolve, reject) => {

queryRunners/TediousQueryRunner.d.ts

@@ -1,4 +0,6 @@
-import type { QueryRunner, DatabaseType } from "./QueryRunner";
+import type { DatabaseType } from "./QueryRunner";
 import type { Connection, TediousType } from 'tedious';
-export declare class TediousQueryRunner implements QueryRunner {
+import { AbstractQueryRunner } from "./AbstractQueryRunner";
+import { UnwrapPromiseTuple } from "../utils/PromiseProvider";
+export declare class TediousQueryRunner extends AbstractQueryRunner {
     readonly database: DatabaseType;
@@ -28,2 +30,3 @@ readonly connection: Connection;
     createResolvedPromise<RESULT>(result: RESULT): Promise<RESULT>;
+    createAllPromise<P extends Promise<any>[]>(promises: [...P]): Promise<UnwrapPromiseTuple<P>>;
     protected predefinedTypes: {
@@ -30,0 +33,0 @@ [type: string]: TediousType | undefined;

queryRunners/TediousQueryRunner.js

@@ -5,4 +5,6 @@ "use strict";
 const tedious_1 = require("tedious");
-class TediousQueryRunner {
+const AbstractQueryRunner_1 = require("./AbstractQueryRunner");
+class TediousQueryRunner extends AbstractQueryRunner_1.AbstractQueryRunner {
     constructor(connection) {
+        super();
         this.predefinedTypes = {
@@ -366,2 +368,5 @@ boolean: tedious_1.TYPES.Bit,
     }
+    createAllPromise(promises) {
+        return Promise.all(promises);
+    }
     getType(params, index) {
@@ -368,0 +373,0 @@ const definedType = params['@' + index];

utils/attachSource.d.ts

 export declare function attachSource(error: Error, source: Error): Error;
+export declare function attachTransactionSource(error: Error, source: Error): Error;

utils/attachSource.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.attachSource = void 0;
+exports.attachTransactionSource = exports.attachSource = void 0;
 function attachSource(error, source) {
@@ -15,2 +15,13 @@ Object.defineProperty(error, 'source', {
 exports.attachSource = attachSource;
+function attachTransactionSource(error, source) {
+    Object.defineProperty(error, 'transactionSource', {
+        value: source,
+        writable: true,
+        enumerable: false,
+        configurable: true
+    });
+    error.stack = error.stack + '\nTransaction source: ' + source.stack;
+    return error;
+}
+exports.attachTransactionSource = attachTransactionSource;
 //# sourceMappingURL=attachSource.js.map

utils/PromiseProvider.d.ts

 export declare type PromiseProvider = PromiseConstructorLike & {
     resolve: typeof Promise.resolve;
     reject: typeof Promise.reject;
+    all(values: any[]): Promise<any[]>;
 };
+export declare type UnwrapPromise<P extends any> = P extends Promise<infer R> ? R : P;
+export declare type UnwrapPromiseTuple<Tuple extends any[]> = {
+    [K in keyof Tuple]: UnwrapPromise<Tuple[K]>;
+};

No alert changes

Improved metrics

Total package byte prevSize

1804617

increased by2.86%

Number of package files

294

increased by2.08%

Lines of code

20842

increased by3.45%

Number of lines in readme file

3322

increased by1.65%

Worsened metrics

Dev dependency count

36

increased by5.88%

No dependency changes