remult 0.13.10 → 0.13.13

package/src/shared-tests/db-tests.db-tests.d.ts

@@ -14,3 +14,13 @@ export declare enum Priority {
     High = 1,
     Critical = 2
 }
+export declare class tasksWithStringEnum extends IdEntity {
+    title: string;
+    completed: boolean;
+    priority: PriorityWithString;
+}
+export declare enum PriorityWithString {
+    Low = "Low",
+    High = "High",
+    Critical = "Critical"
+}

package/src/shared-tests/db-tests.db-tests.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Priority = exports.tasksWithEnum = exports.stam = void 0;
+exports.PriorityWithString = exports.tasksWithStringEnum = exports.Priority = exports.tasksWithEnum = exports.stam = void 0;
 var tslib_1 = require("tslib");
 var data_api_1 = require("../data-api");
 var remult3_1 = require("../remult3");
@@ -58,6 +58,24 @@ db_tests_setup_1.testAll("filter works on all db", function (_a) {
         });
     });
 }, false);
+db_tests_setup_1.testAll("test in statement and ", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var repo, _b;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, entityWithValidations_1.entityWithValidations.create4RowsInDp(createEntity)];
+                case 1:
+                    repo = _c.sent();
+                    _b = expect;
+                    return [4 /*yield*/, repo.count({ myId: [1, 3], $and: [{ myId: [3] }] })];
+                case 2:
+                    _b.apply(void 0, [_c.sent()]).toBe(1);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}, false);
 db_tests_setup_1.testAll("filter with and", function (_a) {
     var createEntity = _a.createEntity;
     return tslib_1.__awaiter(void 0, void 0, void 0, function () {
@@ -1432,22 +1450,97 @@ var Priority;
 db_tests_setup_1.testAll("task with enum", function (_a) {
     var createEntity = _a.createEntity;
     return tslib_1.__awaiter(void 0, void 0, void 0, function () {
-        var r, item;
-        return tslib_1.__generator(this, function (_b) {
-            switch (_b.label) {
+        var r, item, _b, _c;
+        return tslib_1.__generator(this, function (_d) {
+            switch (_d.label) {
                 case 0: return [4 /*yield*/, createEntity(tasksWithEnum)];
                 case 1:
-                    r = _b.sent();
+                    r = _d.sent();
                     return [4 /*yield*/, r.insert({
                             title: 'a',
                             priority: Priority.Critical
                         })];
                 case 2:
-                    _b.sent();
+                    _d.sent();
                     return [4 /*yield*/, r.findFirst()];
                 case 3:
-                    item = _b.sent();
+                    item = _d.sent();
                     expect(item.priority).toBe(Priority.Critical);
+                    _b = expect;
+                    return [4 /*yield*/, r.count({ priority: Priority.Critical })];
+                case 4:
+                    _b.apply(void 0, [_d.sent()]).toBe(1);
+                    _c = expect;
+                    return [4 /*yield*/, r.count({ priority: Priority.Low })];
+                case 5:
+                    _c.apply(void 0, [_d.sent()]).toBe(0);
+                    return [2 /*return*/];
+            }
+        });
+    });
+});
+var tasksWithStringEnum = /** @class */ (function (_super) {
+    tslib_1.__extends(tasksWithStringEnum, _super);
+    function tasksWithStringEnum() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.title = '';
+        _this.completed = false;
+        _this.priority = PriorityWithString.Low;
+        return _this;
+    }
+    tslib_1.__decorate([
+        remult3_1.Fields.string(),
+        tslib_1.__metadata("design:type", Object)
+    ], tasksWithStringEnum.prototype, "title", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.boolean(),
+        tslib_1.__metadata("design:type", Object)
+    ], tasksWithStringEnum.prototype, "completed", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.object(),
+        tslib_1.__metadata("design:type", Object)
+    ], tasksWithStringEnum.prototype, "priority", void 0);
+    tasksWithStringEnum = tslib_1.__decorate([
+        remult3_1.Entity('tasksWithStringEnum', {
+            allowApiCrud: true
+        })
+    ], tasksWithStringEnum);
+    return tasksWithStringEnum;
+}(id_entity_1.IdEntity));
+exports.tasksWithStringEnum = tasksWithStringEnum;
+var PriorityWithString;
+(function (PriorityWithString) {
+    PriorityWithString["Low"] = "Low";
+    PriorityWithString["High"] = "High";
+    PriorityWithString["Critical"] = "Critical";
+})(PriorityWithString = exports.PriorityWithString || (exports.PriorityWithString = {}));
+db_tests_setup_1.testAll("task with enum string", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var r, item, _b, _c;
+        return tslib_1.__generator(this, function (_d) {
+            switch (_d.label) {
+                case 0: return [4 /*yield*/, createEntity(tasksWithStringEnum)];
+                case 1:
+                    r = _d.sent();
+                    return [4 /*yield*/, r.insert({
+                            title: 'a',
+                            priority: PriorityWithString.Critical
+                        })];
+                case 2:
+                    _d.sent();
+                    return [4 /*yield*/, r.findFirst()];
+                case 3:
+                    item = _d.sent();
+                    expect(item.priority).toBe(PriorityWithString.Critical);
+                    _b = expect;
+                    return [4 /*yield*/, r.count({ priority: PriorityWithString.Critical })];
+                case 4:
+                    _b.apply(void 0, [_d.sent()]).toBe(1);
+                    _c = expect;
+                    return [4 /*yield*/, r.count({ priority: PriorityWithString.Low })];
+                case 5:
+                    _c.apply(void 0, [_d.sent()]).toBe(0);
                     return [2 /*return*/];
             }
         });

package/src/tests/frontend-database-tests-setup.spec.d.ts

@@ -0,0 +1,4 @@
+import { dbTestWhatSignature } from "../shared-tests/db-tests-setup";
+export declare function testWebSqlImpl(key: string, what: dbTestWhatSignature, focus?: boolean): void;
+export declare function testRest(key: string, what: dbTestWhatSignature, focus?: boolean): void;
+import '../shared-tests/';

package/src/tests/frontend-database-tests-setup.spec.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testRest = exports.testWebSqlImpl = void 0;
+var tslib_1 = require("tslib");
+var db_tests_setup_1 = require("../shared-tests/db-tests-setup");
+var __1 = require("../..");
+var context_1 = require("../context");
+var sql_database_1 = require("../data-providers/sql-database");
+var web_sql_data_provider_1 = require("../data-providers/web-sql-data-provider");
+var testHelper_spec_1 = require("./testHelper.spec");
+function testWebSqlImpl(key, what, focus) {
+    var _this = this;
+    if (focus === void 0) { focus = false; }
+    db_tests_setup_1.itWithFocus(key + " - WebSql", function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+        var webSql, sql, _a, _b, r, _c, e_1_1, remult;
+        var e_1, _d;
+        var _this = this;
+        return tslib_1.__generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    webSql = new web_sql_data_provider_1.WebSqlDataProvider('test');
+                    sql = new sql_database_1.SqlDatabase(webSql);
+                    _e.label = 1;
+                case 1:
+                    _e.trys.push([1, 11, 12, 13]);
+                    return [4 /*yield*/, sql.execute("select name from sqlite_master where type='table'")];
+                case 2: return [4 /*yield*/, (_e.sent()).rows];
+                case 3:
+                    _a = tslib_1.__values.apply(void 0, [_e.sent()]), _b = _a.next();
+                    _e.label = 4;
+                case 4:
+                    if (!!_b.done) return [3 /*break*/, 10];
+                    r = _b.value;
+                    _c = r.name;
+                    switch (_c) {
+                        case "__WebKitDatabaseInfoTable__": return [3 /*break*/, 5];
+                        case "sqlite_sequence": return [3 /*break*/, 6];
+                    }
+                    return [3 /*break*/, 7];
+                case 5: return [3 /*break*/, 9];
+                case 6: return [3 /*break*/, 9];
+                case 7: return [4 /*yield*/, sql.execute("drop table if exists " + r.name)];
+                case 8:
+                    _e.sent();
+                    _e.label = 9;
+                case 9:
+                    _b = _a.next();
+                    return [3 /*break*/, 4];
+                case 10: return [3 /*break*/, 13];
+                case 11:
+                    e_1_1 = _e.sent();
+                    e_1 = { error: e_1_1 };
+                    return [3 /*break*/, 13];
+                case 12:
+                    try {
+                        if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                    return [7 /*endfinally*/];
+                case 13:
+                    remult = new context_1.Remult();
+                    remult.setDataProvider(sql);
+                    return [4 /*yield*/, what({ db: sql, remult: remult, createEntity: function (x) { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
+                                return [2 /*return*/, remult.repo(x)];
+                            }); }); } })];
+                case 14:
+                    _e.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); }, focus);
+}
+exports.testWebSqlImpl = testWebSqlImpl;
+db_tests_setup_1.addDatabaseToTest(testWebSqlImpl);
+function testRest(key, what, focus) {
+    var _this = this;
+    if (focus === void 0) { focus = false; }
+    db_tests_setup_1.itWithFocus(key + " - Rest Provider", function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+        var r, remult, db;
+        var _this = this;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    r = new context_1.Remult();
+                    r.setDataProvider(new __1.InMemoryDataProvider());
+                    remult = new context_1.Remult();
+                    db = new testHelper_spec_1.MockRestDataProvider(r);
+                    remult.setDataProvider(db);
+                    return [4 /*yield*/, what({ db: db, remult: remult, createEntity: function (x) { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
+                                return [2 /*return*/, remult.repo(x)];
+                            }); }); } })];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); }, focus);
+}
+exports.testRest = testRest;
+db_tests_setup_1.addDatabaseToTest(testRest);
+require("../shared-tests/");

package/src/tests/testHelper.spec.d.ts

@@ -0,0 +1,34 @@
+import './frontend-database-tests-setup.spec';
+import { Remult } from "../context";
+import { DataProvider, EntityDataProvider } from "../data-interfaces";
+import { InMemoryDataProvider } from "../data-providers/in-memory-database";
+import { EntityMetadata } from "../remult3";
+export declare function itForEach<T>(name: string, arrayOfT: T[], runAsync: (item: T) => Promise<any>): void;
+export declare function fitForEach<T>(name: string, arrayOfT: T[], runAsync: (item: T) => Promise<any>): void;
+export declare function testAsIfOnBackend(what: () => Promise<any>): Promise<void>;
+export declare const ActionTestConfig: {
+    db: InMemoryDataProvider;
+};
+export declare function testSql(runAsync: (db: {
+    db: DataProvider;
+    remult: Remult;
+}) => Promise<void>): Promise<void>;
+export declare function testInMemoryDb(runAsync: (db: {
+    db: DataProvider;
+    remult: Remult;
+}) => Promise<void>): Promise<void>;
+export declare function testRestDb(runAsync: (db: {
+    db: DataProvider;
+    remult: Remult;
+}) => Promise<void>): Promise<void>;
+export declare function testAllDataProviders(runAsync: (db: {
+    db: DataProvider;
+    remult: Remult;
+}) => Promise<void>): Promise<void>;
+export declare class MockRestDataProvider implements DataProvider {
+    private remult;
+    constructor(remult: Remult);
+    getEntityDataProvider(metadata: EntityMetadata<any>): EntityDataProvider;
+    transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
+    supportsCustomFilter: boolean;
+}

package/src/tests/testHelper.spec.js

@@ -0,0 +1,369 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockRestDataProvider = exports.testAllDataProviders = exports.testRestDb = exports.testInMemoryDb = exports.testSql = exports.ActionTestConfig = exports.testAsIfOnBackend = exports.fitForEach = exports.itForEach = void 0;
+var tslib_1 = require("tslib");
+require("./frontend-database-tests-setup.spec");
+var context_1 = require("../context");
+var data_api_1 = require("../data-api");
+var in_memory_database_1 = require("../data-providers/in-memory-database");
+var rest_data_provider_1 = require("../data-providers/rest-data-provider");
+var sql_database_1 = require("../data-providers/sql-database");
+var web_sql_data_provider_1 = require("../data-providers/web-sql-data-provider");
+var server_action_1 = require("../server-action");
+var entityWithValidations_1 = require("../shared-tests/entityWithValidations");
+var TestDataApiResponse_1 = require("./TestDataApiResponse");
+jasmine.DEFAULT_TIMEOUT_INTERVAL = 999999;
+//actionInfo.runningOnServer = false;
+function itForEach(name, arrayOfT, runAsync) {
+    arrayOfT.forEach(function (i) {
+        it(name + ' - ' + i, function (done) {
+            runAsync(i).catch(function (e) {
+                fail(e);
+                done();
+            }).then(done, function (e) {
+                fail(e);
+                done();
+            });
+        });
+    });
+}
+exports.itForEach = itForEach;
+function fitForEach(name, arrayOfT, runAsync) {
+    arrayOfT.forEach(function (i) {
+        fit(name + ' - ' + i, function (done) {
+            runAsync(i).catch(function (e) {
+                fail(e);
+                done();
+            }).then(done, function (e) {
+                fail(e);
+                done();
+            });
+        });
+    });
+}
+exports.fitForEach = fitForEach;
+function testAsIfOnBackend(what) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, , 2, 3]);
+                    server_action_1.actionInfo.runningOnServer = true;
+                    return [4 /*yield*/, what()];
+                case 1:
+                    _a.sent();
+                    return [3 /*break*/, 3];
+                case 2:
+                    server_action_1.actionInfo.runningOnServer = false;
+                    return [7 /*endfinally*/];
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.testAsIfOnBackend = testAsIfOnBackend;
+exports.ActionTestConfig = {
+    db: new in_memory_database_1.InMemoryDataProvider()
+};
+server_action_1.Action.provider = {
+    delete: undefined,
+    get: undefined,
+    post: function (urlreq, data) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, new Promise(function (res, r) {
+                        var found = false;
+                        server_action_1.actionInfo.allActions.forEach(function (action) {
+                            action[server_action_1.serverActionField].
+                                __register(function (url, queue, allowed, what) {
+                                if (context_1.Remult.apiBaseUrl + '/' + url == urlreq) {
+                                    found = true;
+                                    var t = new TestDataApiResponse_1.TestDataApiResponse();
+                                    server_action_1.actionInfo.runningOnServer = true;
+                                    t.success = function (data) {
+                                        res(data);
+                                        server_action_1.actionInfo.runningOnServer = false;
+                                    };
+                                    t.error = function (data) {
+                                        r(JSON.parse(JSON.stringify(data_api_1.serializeError(data))));
+                                        server_action_1.actionInfo.runningOnServer = false;
+                                    };
+                                    var remult = new context_1.Remult();
+                                    remult.setDataProvider(exports.ActionTestConfig.db);
+                                    what(JSON.parse(JSON.stringify(data)), remult, t);
+                                }
+                            });
+                        });
+                        if (!found) {
+                            r("did not find " + urlreq);
+                        }
+                    })];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    }); },
+    put: undefined
+};
+function testSql(runAsync) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var webSql, sql, _a, _b, r, _c, e_1_1, remult;
+        var e_1, _d;
+        return tslib_1.__generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    webSql = new web_sql_data_provider_1.WebSqlDataProvider('test');
+                    sql = new sql_database_1.SqlDatabase(webSql);
+                    _e.label = 1;
+                case 1:
+                    _e.trys.push([1, 10, 11, 12]);
+                    return [4 /*yield*/, sql.execute("select name from sqlite_master where type='table'")];
+                case 2: return [4 /*yield*/, (_e.sent()).rows];
+                case 3:
+                    _a = tslib_1.__values.apply(void 0, [_e.sent()]), _b = _a.next();
+                    _e.label = 4;
+                case 4:
+                    if (!!_b.done) return [3 /*break*/, 9];
+                    r = _b.value;
+                    _c = r.name;
+                    switch (_c) {
+                        case "__WebKitDatabaseInfoTable__": return [3 /*break*/, 5];
+                    }
+                    return [3 /*break*/, 6];
+                case 5: return [3 /*break*/, 8];
+                case 6: return [4 /*yield*/, sql.execute("drop table if exists " + r.name)];
+                case 7:
+                    _e.sent();
+                    _e.label = 8;
+                case 8:
+                    _b = _a.next();
+                    return [3 /*break*/, 4];
+                case 9: return [3 /*break*/, 12];
+                case 10:
+                    e_1_1 = _e.sent();
+                    e_1 = { error: e_1_1 };
+                    return [3 /*break*/, 12];
+                case 11:
+                    try {
+                        if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                    return [7 /*endfinally*/];
+                case 12:
+                    remult = new context_1.Remult();
+                    remult.setDataProvider(sql);
+                    return [4 /*yield*/, runAsync({ db: sql, remult: remult })];
+                case 13:
+                    _e.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.testSql = testSql;
+function testInMemoryDb(runAsync) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var remult, db;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    remult = new context_1.Remult();
+                    db = new in_memory_database_1.InMemoryDataProvider();
+                    remult.setDataProvider(db);
+                    return [4 /*yield*/, runAsync({ db: db, remult: remult })];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.testInMemoryDb = testInMemoryDb;
+function testRestDb(runAsync) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var r, remult, db;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    r = new context_1.Remult();
+                    r.setDataProvider(new in_memory_database_1.InMemoryDataProvider());
+                    remult = new context_1.Remult();
+                    db = new MockRestDataProvider(r);
+                    remult.setDataProvider(db);
+                    return [4 /*yield*/, runAsync({ db: db, remult: remult })];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.testRestDb = testRestDb;
+function testAllDataProviders(runAsync) {
+    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*/, testSql(runAsync)];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, testInMemoryDb(runAsync)];
+                case 2:
+                    _a.sent();
+                    return [4 /*yield*/, testRestDb(runAsync)];
+                case 3:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.testAllDataProviders = testAllDataProviders;
+function urlToReq(url) {
+    var e_2, _a;
+    var _b;
+    var args = new Map();
+    var params = (_b = url === null || url === void 0 ? void 0 : url.split('?')[1]) === null || _b === void 0 ? void 0 : _b.split('&');
+    if (params)
+        try {
+            for (var params_1 = tslib_1.__values(params), params_1_1 = params_1.next(); !params_1_1.done; params_1_1 = params_1.next()) {
+                var p = params_1_1.value;
+                if (!p)
+                    continue;
+                var z = p.split('=');
+                var key = decodeURIComponent(z[0]);
+                var value = decodeURIComponent(z[1]);
+                var x = args.get(key);
+                if (x === undefined) {
+                    args.set(key, value);
+                }
+                else if (Array.isArray(x))
+                    x.push(value);
+                else
+                    args.set(key, [args.get(key), value]);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (params_1_1 && !params_1_1.done && (_a = params_1.return)) _a.call(params_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+    var req = {
+        get: function (key) {
+            var r = args.get(key);
+            if (r !== undefined) {
+                r.toString();
+            }
+            return r;
+        }
+    };
+    return req;
+}
+var MockRestDataProvider = /** @class */ (function () {
+    function MockRestDataProvider(remult) {
+        this.remult = remult;
+        this.supportsCustomFilter = true;
+    }
+    MockRestDataProvider.prototype.getEntityDataProvider = function (metadata) {
+        var _this = this;
+        var dataApi = new data_api_1.DataApi(this.remult.repo(metadata.entityType), this.remult);
+        return new rest_data_provider_1.RestEntityDataProvider("", {
+            delete: function (url) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                var urlSplit, r, result;
+                return tslib_1.__generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            urlSplit = url.split('/');
+                            r = new TestDataApiResponse_1.TestDataApiResponse();
+                            r.deleted = function () { };
+                            _a.label = 1;
+                        case 1:
+                            _a.trys.push([1, , 3, 4]);
+                            entityWithValidations_1.testConfiguration.restDbRunningOnServer = true;
+                            return [4 /*yield*/, dataApi.delete(r, urlSplit[urlSplit.length - 1])];
+                        case 2:
+                            _a.sent();
+                            return [3 /*break*/, 4];
+                        case 3:
+                            entityWithValidations_1.testConfiguration.restDbRunningOnServer = false;
+                            return [7 /*endfinally*/];
+                        case 4: return [2 /*return*/, result];
+                    }
+                });
+            }); },
+            get: function (url) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                var r, result;
+                return tslib_1.__generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            r = new TestDataApiResponse_1.TestDataApiResponse();
+                            r.success = function (data) { result = data; };
+                            _a.label = 1;
+                        case 1:
+                            _a.trys.push([1, , 3, 4]);
+                            entityWithValidations_1.testConfiguration.restDbRunningOnServer = true;
+                            return [4 /*yield*/, dataApi.httpGet(r, urlToReq(url))];
+                        case 2:
+                            _a.sent();
+                            return [3 /*break*/, 4];
+                        case 3:
+                            entityWithValidations_1.testConfiguration.restDbRunningOnServer = false;
+                            return [7 /*endfinally*/];
+                        case 4: return [2 /*return*/, result];
+                    }
+                });
+            }); },
+            post: function (url, data) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                var r, result;
+                return tslib_1.__generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            r = new TestDataApiResponse_1.TestDataApiResponse();
+                            r.created = function (data) { result = data; };
+                            r.success = function (data) { result = data; };
+                            _a.label = 1;
+                        case 1:
+                            _a.trys.push([1, , 3, 4]);
+                            entityWithValidations_1.testConfiguration.restDbRunningOnServer = true;
+                            return [4 /*yield*/, dataApi.httpPost(r, urlToReq(url), data)];
+                        case 2:
+                            _a.sent();
+                            return [3 /*break*/, 4];
+                        case 3:
+                            entityWithValidations_1.testConfiguration.restDbRunningOnServer = false;
+                            return [7 /*endfinally*/];
+                        case 4: return [2 /*return*/, result];
+                    }
+                });
+            }); },
+            put: function (url, data) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                var urlSplit, r, result;
+                return tslib_1.__generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            urlSplit = url.split('/');
+                            r = new TestDataApiResponse_1.TestDataApiResponse();
+                            r.success = function (data) { result = data; };
+                            _a.label = 1;
+                        case 1:
+                            _a.trys.push([1, , 3, 4]);
+                            entityWithValidations_1.testConfiguration.restDbRunningOnServer = true;
+                            return [4 /*yield*/, dataApi.put(r, urlSplit[urlSplit.length - 1], data)];
+                        case 2:
+                            _a.sent();
+                            return [3 /*break*/, 4];
+                        case 3:
+                            entityWithValidations_1.testConfiguration.restDbRunningOnServer = false;
+                            return [7 /*endfinally*/];
+                        case 4: return [2 /*return*/, result];
+                    }
+                });
+            }); }
+        }, metadata);
+    };
+    MockRestDataProvider.prototype.transaction = function (action) {
+        throw new Error('Method not implemented.');
+    };
+    return MockRestDataProvider;
+}());
+exports.MockRestDataProvider = MockRestDataProvider;