remult 0.13.11 → 0.13.12

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.13.11",
+    "version": "0.13.12",
     "description": "remult core lib",
     "homepage": "https://remult.dev/",
     "repository": {

package/readme.md

@@ -99,23 +99,26 @@ static async increasePriceOfTofu(priceIncrease: number, remult?: Remult) {
 ## :ballot_box_with_check: Data validation and constraints - defined once
 
 ```ts
-import { Entity, EntityBase, Field } from 'remult';
-import { Min } from 'class-validator';
+import { Entity, EntityBase, Fields } from 'remult';
 
 @Entity('products', {
     allowApiCrud: true
 })
 export class Product extends EntityBase {
     @Fields.string<Product>({
-        validate: p => {
-            if (p.name.trim().length == 0)
-                p.$.name.error = 'required';
+        validate: product => {
+            if (product.name.trim().length == 0)
+                product.$.name.error = 'required';
         }
     })
     name = '';
 
-    @Fields.number()
-    @Min(0)
+    @Fields.number({
+        validate: (_, field) => {
+            if (field.value < 0)
+                field.error = "must not be less than 0";
+        }
+    })
     unitPrice = 0;
 }
 ```
@@ -136,7 +139,7 @@ catch {
 ```sh
 > curl -d "{""unitPrice"":-1}" -H "Content-Type: application/json" -X POST http://localhost:3001/api/products
 
-{"modelState":{"unitPrice":"unitPrice must not be less than 0","name":"required"},"message":"Name: required"}
+{"modelState":{"unitPrice":"must not be less than 0","name":"required"},"message":"Name: required"}
 ```
 
 ## :lock: Secure the API with fine-grained authorization

package/src/filter/filter-interfaces.js

@@ -397,11 +397,12 @@ function entityFilterToJson(entityDefs, where) {
 }
 exports.entityFilterToJson = entityFilterToJson;
 function buildFilterFromRequestParameters(entity, filterInfo) {
-    var e_3, _a, _b;
+    var _a;
     var where = [];
     tslib_1.__spread(entity.fields).forEach(function (col) {
         var _a, _b;
         function addFilter(operation, theFilter, jsonArray, asString) {
+            var e_3, _a;
             if (jsonArray === void 0) { jsonArray = false; }
             if (asString === void 0) { asString = false; }
             var val = filterInfo.get(col.key + operation);
@@ -430,8 +431,26 @@ function buildFilterFromRequestParameters(entity, filterInfo) {
                         addFilter_1(v);
                     });
                 }
-                else
-                    addFilter_1(val);
+                else {
+                    if (jsonArray) {
+                        if (typeof val === 'string')
+                            val = JSON.parse(val);
+                    }
+                    var array = separateArrayFromInnerArray(val);
+                    try {
+                        for (var array_1 = tslib_1.__values(array), array_1_1 = array_1.next(); !array_1_1.done; array_1_1 = array_1.next()) {
+                            var x = array_1_1.value;
+                            addFilter_1(x);
+                        }
+                    }
+                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                    finally {
+                        try {
+                            if (array_1_1 && !array_1_1.done && (_a = array_1.return)) _a.call(array_1);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                    }
+                }
             }
         }
         var c = new filterHelper(col);
@@ -460,6 +479,29 @@ function buildFilterFromRequestParameters(entity, filterInfo) {
     });
     var val = filterInfo.get('OR');
     if (val) {
+        var array = separateArrayFromInnerArray(val);
+        where.push({
+            $and: array.map(function (v) { return ({
+                $or: v.map(function (x) {
+                    return buildFilterFromRequestParameters(entity, { get: function (key) { return x[key]; } });
+                })
+            }); })
+        });
+    }
+    for (var key in entity.entityType) {
+        var element = entity.entityType[key];
+        if (element && element.customFilterInfo && element.customFilterInfo.customFilterTranslator) {
+            var custom = filterInfo.get(exports.customUrlToken + key);
+            if (custom !== undefined) {
+                where.push((_a = {}, _a[exports.customUrlToken + key] = custom, _a));
+            }
+        }
+    }
+    return { $and: where };
+    function separateArrayFromInnerArray(val) {
+        var e_4, _a;
+        if (!Array.isArray(val))
+            return [val];
         var nonArray = [], array = [];
         try {
             for (var val_1 = tslib_1.__values(val), val_1_1 = val_1.next(); !val_1_1.done; val_1_1 = val_1.next()) {
@@ -471,32 +513,16 @@ function buildFilterFromRequestParameters(entity, filterInfo) {
                     nonArray.push(v);
             }
         }
-        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
         finally {
             try {
                 if (val_1_1 && !val_1_1.done && (_a = val_1.return)) _a.call(val_1);
             }
-            finally { if (e_3) throw e_3.error; }
+            finally { if (e_4) throw e_4.error; }
         }
         array.push(nonArray);
-        where.push({
-            $and: array.map(function (v) { return ({
-                $or: v.map(function (x) {
-                    return buildFilterFromRequestParameters(entity, { get: function (key) { return x[key]; } });
-                })
-            }); })
-        });
-    }
-    for (var key in entity.entityType) {
-        var element = entity.entityType[key];
-        if (element && element.customFilterInfo && element.customFilterInfo.customFilterTranslator) {
-            var custom = filterInfo.get(exports.customUrlToken + key);
-            if (custom !== undefined) {
-                where.push((_b = {}, _b[exports.customUrlToken + key] = custom, _b));
-            }
-        }
+        return array;
     }
-    return { $and: where };
 }
 exports.buildFilterFromRequestParameters = buildFilterFromRequestParameters;
 var customTranslator = /** @class */ (function () {

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

@@ -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 () {

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;