@technicity/data-service-generator 0.14.1 → 0.14.2

package/dist/runtime/Cache.js

@@ -1,10 +1,13 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const crypto_1 = require("crypto");
-const ioredis_1 = require("ioredis");
-const loglevel_1 = require("loglevel");
+const ioredis_1 = __importDefault(require("ioredis"));
+const loglevel_1 = __importDefault(require("loglevel"));
 const utility_1 = require("./lib/utility");
-const Stats_1 = require("./Stats");
+const Stats_1 = __importDefault(require("./Stats"));
 class Cache {
     constructor(redisConfig, debug) {
         this.waiting = new Set();

package/dist/runtime/IRuntime.d.ts

@@ -5,28 +5,35 @@ export interface IRuntime {
     $whereNeedsProcessing(where: any): boolean;
     $prepareWhere(artifacts: IArtifacts, table: string, data: any): Promise<any>;
     $shutdown(): Promise<void>;
+    $startTransaction(input?: {
+        isolationLevel?: "READ UNCOMMITTED" | "READ COMMITTED" | "REPEATABLE READ" | "SERIALIZABLE";
+    }): Promise<TBeginTransactionResult>;
 }
+export declare type TAction = "findUnique" | "findMany" | "findManyPaginated" | "create" | "update" | "updateMany" | "delete" | "deleteMany";
 export declare type TResolveParams = {
     resource: string;
-    action: "findUnique" | "findMany" | "findManyPaginated" | "create" | "update" | "updateMany" | "delete" | "deleteMany";
-    args?: IArgs | undefined;
+    action: TAction;
+    args?: IArgs;
     data?: any;
     artifacts: IArtifacts;
-    fields?: IField[] | undefined;
-    context?: TContext | undefined;
+    fields?: TSelect;
+    context?: TContext;
     skipCache?: boolean;
+    dbCall?: TDbCall;
 };
 export declare type TContext = {
     [k: string]: any;
 };
 export declare type TMiddleware = (params: TResolveParams, next: (params: TResolveParams) => Promise<any>) => Promise<any>;
-export declare type IDialect = "mysql" | "mssql" | "ksql";
+export declare type IDialect = "mysql" | "mssql" | "sqlite";
 export declare type TDbCall = (q: string) => Promise<any>;
 export declare type TFormatQuery = (q: string, values: any[]) => string;
-export declare type TBeginTransaction = () => Promise<{
+export declare type TBeginTransaction = () => Promise<TBeginTransactionResult>;
+declare type TBeginTransactionResult = {
     dbCall: (q: string) => Promise<any>;
     commit: () => Promise<void>;
-}>;
+    rollback: () => Promise<void>;
+};
 export declare type ISupplementClientOpts = boolean;
 export declare type IOrderBy = {
     column: string;
@@ -35,12 +42,10 @@ export declare type IOrderBy = {
 export declare type IArgs = {
     [k: string]: any;
 };
-export declare type IField = string | {
-    name: string;
-    as?: string;
-    fields: IField[];
-    args?: IArgs;
-    transform?: (record: any) => any;
+export declare type TSelect = {
+    [k: string]: boolean | {
+        $fields?: TSelect;
+    };
 };
 declare type IWhere = (table: string, args: IArgs) => string | undefined;
 declare type IASTChildColumn = {
@@ -48,14 +53,14 @@ declare type IASTChildColumn = {
     name: string;
     fieldName: string;
     as: string;
-    fromOtherTable?: string | undefined;
+    fromOtherTable?: string;
 };
 declare type IASTChildComposite = {
     type: "composite";
     name: string[];
     fieldName: string;
     as: string;
-    fromOtherTable?: string | undefined;
+    fromOtherTable?: string;
 };
 declare type ISqlJoin = (t1: string, t2: string, args: IArgs) => string;
 declare type ISqlBatch = {
@@ -81,7 +86,7 @@ declare type IJunction = {
 export declare type IGetSQLASTInput = {
     table: string;
     fieldName: string;
-    fields: IField[];
+    fields: TSelect;
     args?: IArgs;
     where?: IWhere;
     sqlJoin?: ISqlJoin;
@@ -89,7 +94,7 @@ export declare type IGetSQLASTInput = {
     junction?: IJunction;
     grabMany: boolean;
     getWhere: (table: string, args: any, dialect: IDialect, orderBy?: IOrderBy | undefined, rowWithMatchingCursor?: any) => string | null;
-    orderBy?: IOrderBy | undefined;
+    orderBy?: IOrderBy;
     rowWithMatchingCursor?: any;
     artifacts: IArtifacts;
     dialect: IDialect;
@@ -153,6 +158,30 @@ export declare type IArtifacts = {
             [k: string]: boolean;
         };
         dateTimeFieldsCount: number;
+        fields: TField[];
+        dump: {
+            schema: string;
+        } | null;
     };
 };
+export declare type TFieldType = "string" | "boolean" | "number" | "integer";
+export declare type TField = {
+    kind: "scalar";
+    type: TFieldType;
+    name: string;
+    nullable: boolean;
+    hasDefaultValue: boolean;
+    mapped?: true;
+} | {
+    kind: "enum";
+    values: unknown[];
+    name: string;
+    nullable: boolean;
+} | {
+    kind: "object";
+    type: string;
+    name: string;
+    isList: boolean;
+    nullable: boolean;
+};
 export {};

package/dist/runtime/RuntimeMSSQL.d.ts

@@ -13,7 +13,13 @@ export declare class RuntimeMSSQL implements IRuntime {
     $whereNeedsProcessing(where: any): boolean;
     $prepareWhere(artifacts: IArtifacts, table: string, data: any): Promise<{}>;
     $shutdown(): Promise<void>;
+    $startTransaction(input?: {
+        isolationLevel?: "READ UNCOMMITTED" | "READ COMMITTED" | "REPEATABLE READ" | "SERIALIZABLE";
+    }): Promise<{
+        commit: () => Promise<void>;
+        rollback: () => Promise<void>;
+        dbCall: (q: string) => Promise<any>;
+    }>;
     private dbCall;
     private formatQuery;
-    private beginTransaction;
 }

package/dist/runtime/RuntimeMSSQL.js

@@ -27,7 +27,7 @@ class RuntimeMSSQL {
         __classPrivateFieldSet(this, _RuntimeMSSQL_middlewareHandler, new shared_1.MiddlewareHandler(), "f");
     }
     async resolve(input) {
-        return (0, shared_1.resolve)(input, this.dbCall.bind(this), this.formatQuery.bind(this), this.beginTransaction.bind(this), __classPrivateFieldGet(this, _RuntimeMSSQL_dialect, "f"), __classPrivateFieldGet(this, _RuntimeMSSQL_middlewareHandler, "f"), input.context ?? {});
+        return (0, shared_1.resolve)(input, input.dbCall ?? this.dbCall.bind(this), this.formatQuery.bind(this), this.$startTransaction.bind(this), __classPrivateFieldGet(this, _RuntimeMSSQL_dialect, "f"), __classPrivateFieldGet(this, _RuntimeMSSQL_middlewareHandler, "f"), input.context ?? {});
     }
     async $queryRaw(sql, values) {
         return this.dbCall(this.formatQuery(sql, values ?? []));
@@ -44,15 +44,15 @@ class RuntimeMSSQL {
     async $shutdown() {
         await __classPrivateFieldGet(this, _RuntimeMSSQL_mssqlClient, "f").closePool();
     }
+    async $startTransaction(input) {
+        return __classPrivateFieldGet(this, _RuntimeMSSQL_mssqlClient, "f").beginTransaction(input?.isolationLevel);
+    }
     async dbCall(q) {
         return __classPrivateFieldGet(this, _RuntimeMSSQL_mssqlClient, "f").dbCall(q);
     }
     formatQuery(q, values) {
         return __classPrivateFieldGet(this, _RuntimeMSSQL_mssqlClient, "f").formatQuery(q, values);
     }
-    beginTransaction() {
-        return __classPrivateFieldGet(this, _RuntimeMSSQL_mssqlClient, "f").beginTransaction();
-    }
 }
 exports.RuntimeMSSQL = RuntimeMSSQL;
 _RuntimeMSSQL_dialect = new WeakMap(), _RuntimeMSSQL_mssqlClient = new WeakMap(), _RuntimeMSSQL_middlewareHandler = new WeakMap();

package/dist/runtime/RuntimeMySQL.d.ts

@@ -14,7 +14,9 @@ export declare class RuntimeMySQL implements IRuntime {
     $whereNeedsProcessing(where: any): boolean;
     $prepareWhere(artifacts: IArtifacts, table: string, data: any): Promise<{}>;
     $shutdown(): Promise<void>;
+    $startTransaction(input?: {
+        isolationLevel?: "READ UNCOMMITTED" | "READ COMMITTED" | "REPEATABLE READ" | "SERIALIZABLE";
+    }): Promise<any>;
     private dbCall;
     private formatQuery;
-    private beginTransaction;
 }

package/dist/runtime/RuntimeMySQL.js

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
@@ -10,14 +33,17 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 var _RuntimeMySQL_dialect, _RuntimeMySQL_mysqlClient, _RuntimeMySQL_clientCache, _RuntimeMySQL_middlewareHandler;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RuntimeMySQL = void 0;
-const SqlString = require("sqlstring");
-const Cache_1 = require("./Cache");
+const SqlString = __importStar(require("sqlstring"));
+const Cache_1 = __importDefault(require("./Cache"));
 const MySQL_1 = require("./lib/MySQL");
 const shared_1 = require("./lib/shared");
-const loglevel_1 = require("loglevel");
+const loglevel_1 = __importDefault(require("loglevel"));
 loglevel_1.default.setDefaultLevel("INFO");
 class RuntimeMySQL {
     constructor(clientOpts, otherOpts, artifacts) {
@@ -70,7 +96,7 @@ class RuntimeMySQL {
         __classPrivateFieldSet(this, _RuntimeMySQL_mysqlClient, new MySQL_1.MySQL(clientOpts), "f");
     }
     async resolve(input) {
-        return (0, shared_1.resolve)(input, this.dbCall.bind(this), this.formatQuery.bind(this), this.beginTransaction.bind(this), __classPrivateFieldGet(this, _RuntimeMySQL_dialect, "f"), __classPrivateFieldGet(this, _RuntimeMySQL_middlewareHandler, "f"), input.context ?? {}, __classPrivateFieldGet(this, _RuntimeMySQL_clientCache, "f"));
+        return (0, shared_1.resolve)(input, input.dbCall ?? this.dbCall.bind(this), this.formatQuery.bind(this), this.$startTransaction.bind(this), __classPrivateFieldGet(this, _RuntimeMySQL_dialect, "f"), __classPrivateFieldGet(this, _RuntimeMySQL_middlewareHandler, "f"), input.context ?? {}, __classPrivateFieldGet(this, _RuntimeMySQL_clientCache, "f"));
     }
     async $queryRaw(sql, values) {
         return this.dbCall(this.formatQuery(sql, values ?? []));
@@ -90,15 +116,15 @@ class RuntimeMySQL {
         }
         await __classPrivateFieldGet(this, _RuntimeMySQL_mysqlClient, "f").endPool();
     }
+    async $startTransaction(input) {
+        return __classPrivateFieldGet(this, _RuntimeMySQL_mysqlClient, "f").beginTransaction(input?.isolationLevel);
+    }
     dbCall(q) {
         return __classPrivateFieldGet(this, _RuntimeMySQL_mysqlClient, "f").query(q);
     }
     formatQuery(q, values) {
         return SqlString.format(q, values);
     }
-    beginTransaction() {
-        return __classPrivateFieldGet(this, _RuntimeMySQL_mysqlClient, "f").beginTransaction();
-    }
 }
 exports.RuntimeMySQL = RuntimeMySQL;
 _RuntimeMySQL_dialect = new WeakMap(), _RuntimeMySQL_mysqlClient = new WeakMap(), _RuntimeMySQL_clientCache = new WeakMap(), _RuntimeMySQL_middlewareHandler = new WeakMap();

package/dist/runtime/RuntimeSQLite.d.ts

@@ -0,0 +1,38 @@
+import Database from "better-sqlite3";
+import type { IRuntime, TMiddleware, TResolveParams, IArtifacts, ISupplementClientOpts } from "./IRuntime";
+import { MiddlewareHandler } from "./lib/shared";
+declare type TClientOpts = {
+    filename: string;
+} & Parameters<typeof Database>[1];
+export declare class RuntimeSQLite implements IRuntime {
+    #private;
+    __middlewareHandler: MiddlewareHandler<TMiddleware>;
+    constructor(clientOpts: TClientOpts, otherOpts: {
+        createTablesString?: string;
+        seedString?: string;
+        supplementClientOpts?: ISupplementClientOpts;
+    }, artifacts: IArtifacts);
+    resolve(input: TResolveParams): Promise<any>;
+    $queryRaw(sql: string, values?: any[]): Promise<any[] | {
+        insertId: number | bigint;
+    }>;
+    $use(middleware: TMiddleware): Promise<void>;
+    $whereNeedsProcessing(where: any): boolean;
+    $prepareWhere(artifacts: IArtifacts, table: string, data: any): Promise<{}>;
+    $shutdown(): Promise<void>;
+    $startTransaction(input?: {
+        isolationLevel?: "READ UNCOMMITTED" | "READ COMMITTED" | "REPEATABLE READ" | "SERIALIZABLE";
+    }): Promise<{
+        commit: () => Promise<void>;
+        rollback: () => Promise<void>;
+        dbCall: (q: string) => Promise<any[] | {
+            insertId: number | bigint;
+        }>;
+    }>;
+    private dbCall;
+    private formatQuery;
+    private dbCallTransaction;
+    private commit;
+    private rollback;
+}
+export {};

package/dist/runtime/RuntimeSQLite.js

@@ -0,0 +1,135 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _RuntimeSQLite_dialect, _RuntimeSQLite_db;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeSQLite = void 0;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+// @ts-expect-error
+const SqliteString = __importStar(require("sqlstring-sqlite"));
+const shared_1 = require("./lib/shared");
+class RuntimeSQLite {
+    constructor(clientOpts, otherOpts, artifacts) {
+        _RuntimeSQLite_dialect.set(this, "sqlite");
+        _RuntimeSQLite_db.set(this, void 0);
+        const { filename, ...restOpts } = clientOpts;
+        this.__middlewareHandler = new shared_1.MiddlewareHandler();
+        __classPrivateFieldSet(this, _RuntimeSQLite_db, new better_sqlite3_1.default(filename, restOpts), "f");
+        if (clientOpts.filename === ":memory:") {
+            if (!otherOpts.createTablesString) {
+                throw new Error(`\`createTablesString\` must be supplied when filename is \`:memory:\`.`);
+            }
+            __classPrivateFieldGet(this, _RuntimeSQLite_db, "f").exec(otherOpts.createTablesString);
+            if (otherOpts.seedString) {
+                __classPrivateFieldGet(this, _RuntimeSQLite_db, "f").exec(otherOpts.seedString);
+            }
+        }
+    }
+    async resolve(input) {
+        return (0, shared_1.resolve)(input, input.dbCall ?? this.dbCall.bind(this), this.formatQuery.bind(this), this.$startTransaction.bind(this), __classPrivateFieldGet(this, _RuntimeSQLite_dialect, "f"), this.__middlewareHandler, input.context ?? {});
+    }
+    async $queryRaw(sql, values) {
+        return this.dbCall(this.formatQuery(sql, values ?? []));
+    }
+    async $use(middleware) {
+        this.__middlewareHandler.register(middleware);
+    }
+    $whereNeedsProcessing(where) {
+        return (0, shared_1.whereNeedsProcessing)(where);
+    }
+    async $prepareWhere(artifacts, table, data) {
+        return (0, shared_1._prepareWhere)(artifacts, table, data, this.dbCall.bind(this), this.formatQuery.bind(this));
+    }
+    async $shutdown() {
+        __classPrivateFieldGet(this, _RuntimeSQLite_db, "f").close();
+    }
+    async $startTransaction(input) {
+        const isolationLevel = input?.isolationLevel;
+        if (isolationLevel != null) {
+            if (isolationLevel !== "READ UNCOMMITTED" &&
+                isolationLevel !== "READ COMMITTED" &&
+                isolationLevel !== "REPEATABLE READ" &&
+                isolationLevel !== "SERIALIZABLE") {
+                throw new Error(`Invalid isolationLevel: ${isolationLevel}`);
+            }
+        }
+        __classPrivateFieldGet(this, _RuntimeSQLite_db, "f").prepare("BEGIN TRANSACTION").run();
+        return {
+            commit: this.commit.bind(this),
+            rollback: this.rollback.bind(this),
+            dbCall: this.dbCallTransaction.bind(this)
+        };
+    }
+    async dbCall(q) {
+        const statement = __classPrivateFieldGet(this, _RuntimeSQLite_db, "f").prepare(q);
+        if (q.startsWith("INSERT") || q.startsWith("UPDATE") || q.startsWith("DELETE")) {
+            const result = statement.run();
+            return { insertId: result.lastInsertRowid };
+        }
+        // TODO: use statement.raw instead of typeCastSqlite? That would stop
+        // working if we start joining instead of batching, though.
+        // https://github.com/WiseLibs/better-sqlite3/blob/master/docs/api.md#rawtogglestate---this
+        return statement.all();
+    }
+    formatQuery(q, values) {
+        return SqliteString.format(q, values);
+    }
+    async dbCallTransaction(...args) {
+        try {
+            return await this.dbCall(...args);
+        }
+        catch (err) {
+            __classPrivateFieldGet(this, _RuntimeSQLite_db, "f").prepare("ROLLBACK").run();
+            throw err;
+        }
+    }
+    async commit() {
+        try {
+            __classPrivateFieldGet(this, _RuntimeSQLite_db, "f").prepare("COMMIT").run();
+        }
+        catch (err) {
+            __classPrivateFieldGet(this, _RuntimeSQLite_db, "f").prepare("ROLLBACK").run();
+            throw err;
+        }
+    }
+    async rollback() {
+        __classPrivateFieldGet(this, _RuntimeSQLite_db, "f").prepare("ROLLBACK").run();
+    }
+}
+exports.RuntimeSQLite = RuntimeSQLite;
+_RuntimeSQLite_dialect = new WeakMap(), _RuntimeSQLite_db = new WeakMap();

package/dist/runtime/lib/MSSQL.d.ts

@@ -5,8 +5,9 @@ export declare class MSSQL {
     dbCall(q: string): Promise<any>;
     private mapResult;
     formatQuery(q: string, values: any[]): any;
-    beginTransaction(): Promise<{
+    beginTransaction(isolationLevel?: "READ UNCOMMITTED" | "READ COMMITTED" | "REPEATABLE READ" | "SERIALIZABLE"): Promise<{
         commit: () => Promise<void>;
+        rollback: () => Promise<void>;
         dbCall: (q: string) => Promise<any>;
     }>;
     closePool(): Promise<void>;

package/dist/runtime/lib/MSSQL.js

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
@@ -13,9 +36,9 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _MSSQL_pool, _MSSQL_poolConnect, _MSSQL_typeCast;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MSSQL = void 0;
-const mssql = require("mssql");
+const mssql = __importStar(require("mssql"));
 // @ts-ignore
-const TSqlString = require("tsqlstring");
+const TSqlString = __importStar(require("tsqlstring"));
 class MSSQL {
     constructor(clientOpts, typeCast) {
         _MSSQL_pool.set(this, void 0);
@@ -42,7 +65,7 @@ class MSSQL {
     formatQuery(q, values) {
         return TSqlString.format(q, values);
     }
-    async beginTransaction() {
+    async beginTransaction(isolationLevel) {
         const transaction = new mssql.Transaction(__classPrivateFieldGet(this, _MSSQL_pool, "f"));
         let rolledBack = false;
         transaction.on("rollback", (aborted) => {
@@ -56,13 +79,18 @@ class MSSQL {
             throw err;
         }
         const mapResult = this.mapResult.bind(this);
-        await transaction.begin();
+        let isolationLevelNumber;
+        if (isolationLevel) {
+            isolationLevelNumber = mssql.ISOLATION_LEVEL[isolationLevel.replace(" ", "_")];
+            if (isolationLevelNumber == null) {
+                throw new Error(`Invalid isolationLevel: ${isolationLevel}`);
+            }
+        }
+        await transaction.begin(isolationLevelNumber);
         return {
             commit: () => transaction.commit().catch(handleError),
-            dbCall: (q) => new mssql.Request(transaction)
-                .query(q)
-                .then(mapResult)
-                .catch(handleError),
+            rollback: () => transaction.rollback(),
+            dbCall: (q) => new mssql.Request(transaction).query(q).then(mapResult).catch(handleError)
         };
     }
     async closePool() {

package/dist/runtime/lib/MySQL.d.ts

@@ -2,7 +2,7 @@ export declare class MySQL {
     pool: any;
     constructor(opts: any);
     query(...args: any[]): any;
-    beginTransaction(): Promise<any>;
+    beginTransaction(isolationLevel?: "READ UNCOMMITTED" | "READ COMMITTED" | "REPEATABLE READ" | "SERIALIZABLE"): Promise<any>;
     getConnection(): Promise<any>;
     endPool(): Promise<void>;
 }

package/dist/runtime/lib/MySQL.js

@@ -13,16 +13,29 @@ class MySQL {
     query(...args) {
         return P.using(this.getConnection(), (connection) => connection.queryAsync(...args));
     }
-    async beginTransaction() {
+    async beginTransaction(isolationLevel) {
         return P.using(this.getConnection(), async (connection) => {
             async function handleError(err) {
                 await connection.rollbackAsync();
                 throw err;
             }
+            // https://dev.mysql.com/doc/refman/8.0/en/set-transaction.html#set-transaction-isolation-level
+            // Without any SESSION or GLOBAL keyword:
+            // The statement applies only to the next single transaction performed within the session.
+            if (isolationLevel != null) {
+                if (isolationLevel !== "READ UNCOMMITTED" &&
+                    isolationLevel !== "READ COMMITTED" &&
+                    isolationLevel !== "REPEATABLE READ" &&
+                    isolationLevel !== "SERIALIZABLE") {
+                    throw new Error(`Invalid isolationLevel: ${isolationLevel}`);
+                }
+                await connection.queryAsync(`SET TRANSACTION ISOLATION LEVEL ${isolationLevel};`);
+            }
             await connection.beginTransactionAsync();
             return {
                 commit: () => connection.commitAsync().catch(handleError),
-                dbCall: (q) => connection.queryAsync(q).catch(handleError),
+                rollback: () => connection.rollbackAsync(),
+                dbCall: (q) => connection.queryAsync(q).catch(handleError)
             };
         });
     }

package/dist/runtime/lib/addNullFallbacks.test.d.ts

@@ -0,0 +1 @@
+export {};