remult 0.14.2 → 0.14.5

package/src/data-providers/sql-database.js

@@ -1,283 +1,173 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SqlDatabase = void 0;
-var tslib_1 = require("tslib");
-var column_1 = require("../column");
-var filter_consumer_bridge_to_sql_request_1 = require("../filter/filter-consumer-bridge-to-sql-request");
-var filter_interfaces_1 = require("../filter/filter-interfaces");
-var sort_1 = require("../sort");
+import { CompoundIdField } from "../column";
+import { FilterConsumerBridgeToSqlRequest, getDbNameProvider } from "../filter/filter-consumer-bridge-to-sql-request";
+import { customDatabaseFilterToken, Filter } from '../filter/filter-interfaces';
+import { Sort } from '../sort';
 // @dynamic
-var SqlDatabase = /** @class */ (function () {
-    function SqlDatabase(sql) {
+export class SqlDatabase {
+    constructor(sql) {
         this.sql = sql;
         this.createdEntities = [];
     }
-    SqlDatabase.prototype.createCommand = function () {
+    createCommand() {
         return new LogSQLCommand(this.sql.createCommand(), SqlDatabase.LogToConsole);
-    };
-    SqlDatabase.prototype.execute = function (sql) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.createCommand().execute(sql)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
+    }
+    async execute(sql) {
+        return await this.createCommand().execute(sql);
+    }
+    getEntityDataProvider(entity) {
+        return new ActualSQLServerDataProvider(entity, this, async (dbName) => {
+            if (this.createdEntities.indexOf(dbName.entityName) < 0) {
+                this.createdEntities.push(dbName.entityName);
+                await this.sql.entityIsUsedForTheFirstTime(entity);
+            }
+        }, this.sql);
+    }
+    transaction(action) {
+        return this.sql.transaction(async (x) => {
+            let completed = false;
+            try {
+                await action(new SqlDatabase({
+                    createCommand: () => {
+                        let c = x.createCommand();
+                        return {
+                            addParameterAndReturnSqlToken: x => c.addParameterAndReturnSqlToken(x),
+                            execute: async (sql) => {
+                                if (completed)
+                                    throw "can't run a command after the transaction was completed";
+                                return c.execute(sql);
+                            }
+                        };
+                    },
+                    getLimitSqlSyntax: this.sql.getLimitSqlSyntax,
+                    entityIsUsedForTheFirstTime: y => x.entityIsUsedForTheFirstTime(y),
+                    transaction: z => x.transaction(z),
+                }));
+            }
+            finally {
+                completed = true;
+            }
         });
-    };
-    SqlDatabase.prototype.getEntityDataProvider = function (entity) {
-        var _this = this;
-        return new ActualSQLServerDataProvider(entity, this, function (dbName) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!(this.createdEntities.indexOf(dbName.entityName) < 0)) return [3 /*break*/, 2];
-                        this.createdEntities.push(dbName.entityName);
-                        return [4 /*yield*/, this.sql.entityIsUsedForTheFirstTime(entity)];
-                    case 1:
-                        _a.sent();
-                        _a.label = 2;
-                    case 2: return [2 /*return*/];
-                }
-            });
-        }); }, this.sql);
-    };
-    SqlDatabase.prototype.transaction = function (action) {
-        var _this = this;
-        return this.sql.transaction(function (x) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-            var completed;
-            var _this = this;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        completed = false;
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, , 3, 4]);
-                        return [4 /*yield*/, action(new SqlDatabase({
-                                createCommand: function () {
-                                    var c = x.createCommand();
-                                    return {
-                                        addParameterAndReturnSqlToken: function (x) { return c.addParameterAndReturnSqlToken(x); },
-                                        execute: function (sql) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                                            return tslib_1.__generator(this, function (_a) {
-                                                if (completed)
-                                                    throw "can't run a command after the transaction was completed";
-                                                return [2 /*return*/, c.execute(sql)];
-                                            });
-                                        }); }
-                                    };
-                                },
-                                getLimitSqlSyntax: this.sql.getLimitSqlSyntax,
-                                entityIsUsedForTheFirstTime: function (y) { return x.entityIsUsedForTheFirstTime(y); },
-                                transaction: function (z) { return x.transaction(z); },
-                            }))];
-                    case 2:
-                        _a.sent();
-                        return [3 /*break*/, 4];
-                    case 3:
-                        completed = true;
-                        return [7 /*endfinally*/];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        }); });
-    };
-    SqlDatabase.customFilter = function (build) {
-        var _a;
-        return _a = {},
-            _a[filter_interfaces_1.customDatabaseFilterToken] = {
+    }
+    static customFilter(build) {
+        return {
+            [customDatabaseFilterToken]: {
                 buildSql: build
-            },
-            _a;
-    };
-    SqlDatabase.LogToConsole = false;
-    SqlDatabase.durationThreshold = 0;
-    return SqlDatabase;
-}());
-exports.SqlDatabase = SqlDatabase;
-var LogSQLCommand = /** @class */ (function () {
-    function LogSQLCommand(origin, allQueries) {
+            }
+        };
+    }
+}
+SqlDatabase.LogToConsole = false;
+SqlDatabase.durationThreshold = 0;
+class LogSQLCommand {
+    constructor(origin, allQueries) {
         this.origin = origin;
         this.allQueries = allQueries;
         this.args = {};
     }
-    LogSQLCommand.prototype.addParameterAndReturnSqlToken = function (val) {
-        var r = this.origin.addParameterAndReturnSqlToken(val);
+    addParameterAndReturnSqlToken(val) {
+        let r = this.origin.addParameterAndReturnSqlToken(val);
         this.args[r] = val;
         return r;
-    };
-    LogSQLCommand.prototype.execute = function (sql) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var start, r, d, err_1;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 2, , 3]);
-                        start = new Date();
-                        return [4 /*yield*/, this.origin.execute(sql)];
-                    case 1:
-                        r = _a.sent();
-                        if (this.allQueries) {
-                            d = new Date().valueOf() - start.valueOf();
-                            if (d > SqlDatabase.durationThreshold) {
-                                console.log({ query: sql, arguments: this.args, duration: d / 1000 });
-                            }
-                        }
-                        return [2 /*return*/, r];
-                    case 2:
-                        err_1 = _a.sent();
-                        console.error({ error: err_1, query: sql, arguments: this.args });
-                        throw err_1;
-                    case 3: return [2 /*return*/];
+    }
+    async execute(sql) {
+        try {
+            let start = new Date();
+            let r = await this.origin.execute(sql);
+            if (this.allQueries) {
+                var d = new Date().valueOf() - start.valueOf();
+                if (d > SqlDatabase.durationThreshold) {
+                    console.log({ query: sql, arguments: this.args, duration: d / 1000 });
                 }
-            });
-        });
-    };
-    return LogSQLCommand;
-}());
-var ActualSQLServerDataProvider = /** @class */ (function () {
-    function ActualSQLServerDataProvider(entity, sql, iAmUsed, strategy) {
+            }
+            return r;
+        }
+        catch (err) {
+            console.error({ error: err, query: sql, arguments: this.args });
+            throw err;
+        }
+    }
+}
+class ActualSQLServerDataProvider {
+    constructor(entity, sql, iAmUsed, strategy) {
         this.entity = entity;
         this.sql = sql;
         this.iAmUsed = iAmUsed;
         this.strategy = strategy;
     }
-    ActualSQLServerDataProvider.prototype.init = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var dbNameProvider;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, filter_consumer_bridge_to_sql_request_1.getDbNameProvider(this.entity)];
-                    case 1:
-                        dbNameProvider = _a.sent();
-                        return [4 /*yield*/, this.iAmUsed(dbNameProvider)];
-                    case 2:
-                        _a.sent();
-                        return [2 /*return*/, dbNameProvider];
-                }
-            });
+    async init() {
+        let dbNameProvider = await getDbNameProvider(this.entity);
+        await this.iAmUsed(dbNameProvider);
+        return dbNameProvider;
+    }
+    async count(where) {
+        let e = await this.init();
+        let select = 'select count(*) count from ' + e.entityName;
+        let r = this.sql.createCommand();
+        if (where) {
+            let wc = new FilterConsumerBridgeToSqlRequest(r, e);
+            where.__applyToConsumer(wc);
+            select += await wc.resolveWhere();
+        }
+        return r.execute(select).then(r => {
+            return +r.rows[0].count;
         });
-    };
-    ActualSQLServerDataProvider.prototype.count = function (where) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var e, select, r, wc, _a;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, this.init()];
-                    case 1:
-                        e = _b.sent();
-                        select = 'select count(*) count from ' + e.entityName;
-                        r = this.sql.createCommand();
-                        if (!where) return [3 /*break*/, 3];
-                        wc = new filter_consumer_bridge_to_sql_request_1.FilterConsumerBridgeToSqlRequest(r, e);
-                        where.__applyToConsumer(wc);
-                        _a = select;
-                        return [4 /*yield*/, wc.resolveWhere()];
-                    case 2:
-                        select = _a + _b.sent();
-                        _b.label = 3;
-                    case 3: return [2 /*return*/, r.execute(select).then(function (r) {
-                            return +r.rows[0].count;
-                        })];
+    }
+    async find(options) {
+        let e = await this.init();
+        let { colKeys, select } = this.buildSelect(e);
+        select = 'select ' + select;
+        select += '\n from ' + e.entityName;
+        let r = this.sql.createCommand();
+        if (options) {
+            if (options.where) {
+                let where = new FilterConsumerBridgeToSqlRequest(r, e);
+                options.where.__applyToConsumer(where);
+                select += await where.resolveWhere();
+            }
+            if (options.limit) {
+                options.orderBy = Sort.createUniqueSort(this.entity, options.orderBy);
+            }
+            if (options.orderBy) {
+                let first = true;
+                let segs = [];
+                for (const s of options.orderBy.Segments) {
+                    if (s.field instanceof CompoundIdField) {
+                        segs.push(...s.field.fields.map(c => ({ field: c, isDescending: s.isDescending })));
+                    }
+                    else
+                        segs.push(s);
                 }
-            });
-        });
-    };
-    ActualSQLServerDataProvider.prototype.find = function (options) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var e, _a, colKeys, select, r, where, _b, first, segs, _loop_1, _c, _d, s, segs_1, segs_1_1, c, page;
-            var e_1, _e, e_2, _f;
-            var _this = this;
-            return tslib_1.__generator(this, function (_g) {
-                switch (_g.label) {
-                    case 0: return [4 /*yield*/, this.init()];
-                    case 1:
-                        e = _g.sent();
-                        _a = this.buildSelect(e), colKeys = _a.colKeys, select = _a.select;
-                        select = 'select ' + select;
-                        select += '\n from ' + e.entityName;
-                        r = this.sql.createCommand();
-                        if (!options) return [3 /*break*/, 4];
-                        if (!options.where) return [3 /*break*/, 3];
-                        where = new filter_consumer_bridge_to_sql_request_1.FilterConsumerBridgeToSqlRequest(r, e);
-                        options.where.__applyToConsumer(where);
-                        _b = select;
-                        return [4 /*yield*/, where.resolveWhere()];
-                    case 2:
-                        select = _b + _g.sent();
-                        _g.label = 3;
-                    case 3:
-                        if (options.limit) {
-                            options.orderBy = sort_1.Sort.createUniqueSort(this.entity, options.orderBy);
-                        }
-                        if (options.orderBy) {
-                            first = true;
-                            segs = [];
-                            _loop_1 = function (s) {
-                                if (s.field instanceof column_1.CompoundIdField) {
-                                    segs.push.apply(segs, tslib_1.__spread(s.field.fields.map(function (c) { return ({ field: c, isDescending: s.isDescending }); })));
-                                }
-                                else
-                                    segs.push(s);
-                            };
-                            try {
-                                for (_c = tslib_1.__values(options.orderBy.Segments), _d = _c.next(); !_d.done; _d = _c.next()) {
-                                    s = _d.value;
-                                    _loop_1(s);
-                                }
-                            }
-                            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                            finally {
-                                try {
-                                    if (_d && !_d.done && (_e = _c.return)) _e.call(_c);
-                                }
-                                finally { if (e_1) throw e_1.error; }
-                            }
-                            try {
-                                for (segs_1 = tslib_1.__values(segs), segs_1_1 = segs_1.next(); !segs_1_1.done; segs_1_1 = segs_1.next()) {
-                                    c = segs_1_1.value;
-                                    if (first) {
-                                        select += ' Order By ';
-                                        first = false;
-                                    }
-                                    else
-                                        select += ', ';
-                                    select += e.nameOf(c.field);
-                                    if (c.isDescending)
-                                        select += ' desc';
-                                }
-                            }
-                            catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                            finally {
-                                try {
-                                    if (segs_1_1 && !segs_1_1.done && (_f = segs_1.return)) _f.call(segs_1);
-                                }
-                                finally { if (e_2) throw e_2.error; }
-                            }
-                        }
-                        if (options.limit) {
-                            page = 1;
-                            if (options.page)
-                                page = options.page;
-                            if (page < 1)
-                                page = 1;
-                            select += ' ' + this.strategy.getLimitSqlSyntax(options.limit, (page - 1) * options.limit);
-                        }
-                        _g.label = 4;
-                    case 4: return [2 /*return*/, r.execute(select).then(function (r) {
-                            return r.rows.map(function (y) {
-                                return _this.buildResultRow(colKeys, y, r);
-                            });
-                        })];
+                for (const c of segs) {
+                    if (first) {
+                        select += ' Order By ';
+                        first = false;
+                    }
+                    else
+                        select += ', ';
+                    select += e.nameOf(c.field);
+                    if (c.isDescending)
+                        select += ' desc';
                 }
+            }
+            if (options.limit) {
+                let page = 1;
+                if (options.page)
+                    page = options.page;
+                if (page < 1)
+                    page = 1;
+                select += ' ' + this.strategy.getLimitSqlSyntax(options.limit, (page - 1) * options.limit);
+            }
+        }
+        return r.execute(select).then(r => {
+            return r.rows.map(y => {
+                return this.buildResultRow(colKeys, y, r);
             });
         });
-    };
-    ActualSQLServerDataProvider.prototype.buildResultRow = function (colKeys, y, r) {
-        var result = {};
-        for (var index = 0; index < colKeys.length; index++) {
-            var col = colKeys[index];
+    }
+    buildResultRow(colKeys, y, r) {
+        let result = {};
+        for (let index = 0; index < colKeys.length; index++) {
+            const col = colKeys[index];
             try {
                 result[col.key] = col.valueConverter.fromDb(y[r.getColumnKeyInResultForIndexInSelect(index)]);
             }
@@ -286,156 +176,86 @@ var ActualSQLServerDataProvider = /** @class */ (function () {
             }
         }
         return result;
-    };
-    ActualSQLServerDataProvider.prototype.buildSelect = function (e) {
-        var e_3, _a;
-        var select = '';
-        var colKeys = [];
-        try {
-            for (var _b = tslib_1.__values(this.entity.fields), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var x = _c.value;
-                if (x.isServerExpression) {
-                }
-                else {
-                    if (colKeys.length > 0)
-                        select += ', ';
-                    select += e.nameOf(x);
-                    colKeys.push(x);
-                }
+    }
+    buildSelect(e) {
+        let select = '';
+        let colKeys = [];
+        for (const x of this.entity.fields) {
+            if (x.isServerExpression) {
             }
-        }
-        catch (e_3_1) { e_3 = { error: e_3_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            else {
+                if (colKeys.length > 0)
+                    select += ', ';
+                select += e.nameOf(x);
+                colKeys.push(x);
             }
-            finally { if (e_3) throw e_3.error; }
         }
-        return { colKeys: colKeys, select: select };
-    };
-    ActualSQLServerDataProvider.prototype.update = function (id, data) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var e, r, f, statement, added, _a, _b, x, v, _c, _d, colKeys, select;
-            var e_4, _e;
-            var _this = this;
-            return tslib_1.__generator(this, function (_f) {
-                switch (_f.label) {
-                    case 0: return [4 /*yield*/, this.init()];
-                    case 1:
-                        e = _f.sent();
-                        r = this.sql.createCommand();
-                        f = new filter_consumer_bridge_to_sql_request_1.FilterConsumerBridgeToSqlRequest(r, e);
-                        filter_interfaces_1.Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
-                        statement = 'update ' + e.entityName + ' set ';
-                        added = false;
-                        try {
-                            for (_a = tslib_1.__values(this.entity.fields), _b = _a.next(); !_b.done; _b = _a.next()) {
-                                x = _b.value;
-                                if (x instanceof column_1.CompoundIdField) {
-                                }
-                                if (e.isDbReadonly(x)) { }
-                                else if (data[x.key] !== undefined) {
-                                    v = x.valueConverter.toDb(data[x.key]);
-                                    if (v !== undefined) {
-                                        if (!added)
-                                            added = true;
-                                        else
-                                            statement += ', ';
-                                        statement += e.nameOf(x) + ' = ' + r.addParameterAndReturnSqlToken(v);
-                                    }
-                                }
-                            }
-                        }
-                        catch (e_4_1) { e_4 = { error: e_4_1 }; }
-                        finally {
-                            try {
-                                if (_b && !_b.done && (_e = _a.return)) _e.call(_a);
-                            }
-                            finally { if (e_4) throw e_4.error; }
-                        }
-                        _c = statement;
-                        return [4 /*yield*/, f.resolveWhere()];
-                    case 2:
-                        statement = _c + _f.sent();
-                        _d = this.buildSelect(e), colKeys = _d.colKeys, select = _d.select;
-                        statement += ' returning ' + select;
-                        return [2 /*return*/, r.execute(statement).then(function (sqlResult) {
-                                return _this.buildResultRow(colKeys, sqlResult.rows[0], sqlResult);
-                            })];
-                }
-            });
-        });
-    };
-    ActualSQLServerDataProvider.prototype.delete = function (id) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var e, r, f, statement, _a;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, this.init()];
-                    case 1:
-                        e = _b.sent();
-                        r = this.sql.createCommand();
-                        f = new filter_consumer_bridge_to_sql_request_1.FilterConsumerBridgeToSqlRequest(r, e);
-                        filter_interfaces_1.Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
-                        statement = 'delete from ' + e.entityName;
-                        _a = statement;
-                        return [4 /*yield*/, f.resolveWhere()];
-                    case 2:
-                        statement = _a + _b.sent();
-                        return [2 /*return*/, r.execute(statement).then(function () { })];
+        return { colKeys, select };
+    }
+    async update(id, data) {
+        let e = await this.init();
+        let r = this.sql.createCommand();
+        let f = new FilterConsumerBridgeToSqlRequest(r, e);
+        Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
+        let statement = 'update ' + e.entityName + ' set ';
+        let added = false;
+        for (const x of this.entity.fields) {
+            if (x instanceof CompoundIdField) {
+            }
+            if (e.isDbReadonly(x)) { }
+            else if (data[x.key] !== undefined) {
+                let v = x.valueConverter.toDb(data[x.key]);
+                if (v !== undefined) {
+                    if (!added)
+                        added = true;
+                    else
+                        statement += ', ';
+                    statement += e.nameOf(x) + ' = ' + r.addParameterAndReturnSqlToken(v);
                 }
-            });
+            }
+        }
+        statement += await f.resolveWhere();
+        let { colKeys, select } = this.buildSelect(e);
+        statement += ' returning ' + select;
+        return r.execute(statement).then(sqlResult => {
+            return this.buildResultRow(colKeys, sqlResult.rows[0], sqlResult);
         });
-    };
-    ActualSQLServerDataProvider.prototype.insert = function (data) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var e, r, cols, vals, added, _a, _b, x, v, statement, _c, colKeys, select;
-            var e_5, _d;
-            var _this = this;
-            return tslib_1.__generator(this, function (_e) {
-                switch (_e.label) {
-                    case 0: return [4 /*yield*/, this.init()];
-                    case 1:
-                        e = _e.sent();
-                        r = this.sql.createCommand();
-                        cols = '';
-                        vals = '';
-                        added = false;
-                        try {
-                            for (_a = tslib_1.__values(this.entity.fields), _b = _a.next(); !_b.done; _b = _a.next()) {
-                                x = _b.value;
-                                if (e.isDbReadonly(x)) { }
-                                else {
-                                    v = x.valueConverter.toDb(data[x.key]);
-                                    if (v != undefined) {
-                                        if (!added)
-                                            added = true;
-                                        else {
-                                            cols += ', ';
-                                            vals += ', ';
-                                        }
-                                        cols += e.nameOf(x);
-                                        vals += r.addParameterAndReturnSqlToken(v);
-                                    }
-                                }
-                            }
-                        }
-                        catch (e_5_1) { e_5 = { error: e_5_1 }; }
-                        finally {
-                            try {
-                                if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
-                            }
-                            finally { if (e_5) throw e_5.error; }
-                        }
-                        statement = "insert into " + e.entityName + " (" + cols + ") values (" + vals + ")";
-                        _c = this.buildSelect(e), colKeys = _c.colKeys, select = _c.select;
-                        statement += ' returning ' + select;
-                        return [4 /*yield*/, r.execute(statement).then(function (sql) { return _this.buildResultRow(colKeys, sql.rows[0], sql); })];
-                    case 2: return [2 /*return*/, _e.sent()];
+    }
+    async delete(id) {
+        let e = await this.init();
+        let r = this.sql.createCommand();
+        let f = new FilterConsumerBridgeToSqlRequest(r, e);
+        Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
+        let statement = 'delete from ' + e.entityName;
+        statement += await f.resolveWhere();
+        return r.execute(statement).then(() => { });
+    }
+    async insert(data) {
+        let e = await this.init();
+        let r = this.sql.createCommand();
+        let cols = '';
+        let vals = '';
+        let added = false;
+        for (const x of this.entity.fields) {
+            if (e.isDbReadonly(x)) { }
+            else {
+                let v = x.valueConverter.toDb(data[x.key]);
+                if (v != undefined) {
+                    if (!added)
+                        added = true;
+                    else {
+                        cols += ', ';
+                        vals += ', ';
+                    }
+                    cols += e.nameOf(x);
+                    vals += r.addParameterAndReturnSqlToken(v);
                 }
-            });
-        });
-    };
-    ActualSQLServerDataProvider.LogToConsole = false;
-    return ActualSQLServerDataProvider;
-}());
+            }
+        }
+        let statement = `insert into ${e.entityName} (${cols}) values (${vals})`;
+        let { colKeys, select } = this.buildSelect(e);
+        statement += ' returning ' + select;
+        return await r.execute(statement).then(sql => this.buildResultRow(colKeys, sql.rows[0], sql));
+    }
+}
+ActualSQLServerDataProvider.LogToConsole = false;