remult 0.14.6 → 0.14.7

package/src/tests/testHelper.spec.js

@@ -1,143 +1,256 @@
-import './frontend-database-tests-setup.spec';
-import { HttpProviderBridgeToRestDataProviderHttpProvider, Remult } from "../context";
-import { DataApi, serializeError } from "../data-api";
-import { InMemoryDataProvider } from "../data-providers/in-memory-database";
-import { RestEntityDataProvider } from "../data-providers/rest-data-provider";
-import { SqlDatabase } from "../data-providers/sql-database";
-import { WebSqlDataProvider } from "../data-providers/web-sql-data-provider";
-import { Action, actionInfo, serverActionField } from "../server-action";
-import { testConfiguration } from '../shared-tests/entityWithValidations';
-import { TestDataApiResponse } from './TestDataApiResponse';
+"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;
-export function itForEach(name, arrayOfT, runAsync) {
-    arrayOfT.forEach(i => {
-        it(name + ' - ' + i, (done) => {
-            runAsync(i).catch(e => {
+function itForEach(name, arrayOfT, runAsync) {
+    arrayOfT.forEach(function (i) {
+        it(name + ' - ' + i, function (done) {
+            runAsync(i).catch(function (e) {
                 fail(e);
                 done();
-            }).then(done, e => {
+            }).then(done, function (e) {
                 fail(e);
                 done();
             });
         });
     });
 }
-export function fitForEach(name, arrayOfT, runAsync) {
-    arrayOfT.forEach(i => {
-        fit(name + ' - ' + i, (done) => {
-            runAsync(i).catch(e => {
+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, e => {
+            }).then(done, function (e) {
                 fail(e);
                 done();
             });
         });
     });
 }
-export async function testAsIfOnBackend(what) {
-    try {
-        actionInfo.runningOnServer = true;
-        await what();
-    }
-    finally {
-        actionInfo.runningOnServer = false;
-    }
+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*/];
+            }
+        });
+    });
 }
-export const ActionTestConfig = {
-    db: new InMemoryDataProvider()
+exports.testAsIfOnBackend = testAsIfOnBackend;
+exports.ActionTestConfig = {
+    db: new in_memory_database_1.InMemoryDataProvider()
 };
-Action.provider = {
+server_action_1.Action.provider = {
     delete: undefined,
     get: undefined,
-    post: async (urlreq, data) => {
-        return await new Promise((res, r) => {
-            let found = false;
-            actionInfo.allActions.forEach(action => {
-                action[serverActionField].
-                    __register((url, queue, allowed, what) => {
-                    if (Remult.apiBaseUrl + '/' + url == urlreq) {
-                        found = true;
-                        let t = new TestDataApiResponse();
-                        actionInfo.runningOnServer = true;
-                        t.success = data => {
-                            res(data);
-                            actionInfo.runningOnServer = false;
-                        };
-                        t.error = data => {
-                            r(JSON.parse(JSON.stringify(serializeError(data))));
-                            actionInfo.runningOnServer = false;
-                        };
-                        let remult = new Remult();
-                        remult.setDataProvider(ActionTestConfig.db);
-                        what(JSON.parse(JSON.stringify(data)), remult, t);
-                    }
-                });
-            });
-            if (!found) {
-                r("did not find " + urlreq);
+    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
 };
-export async function testSql(runAsync) {
-    let webSql = new WebSqlDataProvider('test');
-    const sql = new SqlDatabase(webSql);
-    for (const r of await (await sql.execute("select name from sqlite_master where type='table'")).rows) {
-        switch (r.name) {
-            case "__WebKitDatabaseInfoTable__":
-                break;
-            default:
-                await sql.execute("drop table if exists " + r.name);
-        }
-    }
-    let remult = new Remult();
-    remult.setDataProvider(sql);
-    await runAsync({ db: sql, remult });
+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*/];
+            }
+        });
+    });
 }
-export async function testInMemoryDb(runAsync) {
-    let remult = new Remult();
-    let db = new InMemoryDataProvider();
-    remult.setDataProvider(db);
-    await runAsync({ db, remult });
+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*/];
+            }
+        });
+    });
 }
-export async function testRestDb(runAsync) {
-    let r = new Remult();
-    r.setDataProvider(new InMemoryDataProvider());
-    let remult = new Remult();
-    let db = new MockRestDataProvider(r);
-    remult.setDataProvider(db);
-    await runAsync({ db, remult });
+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*/];
+            }
+        });
+    });
 }
-export async function testAllDataProviders(runAsync) {
-    await testSql(runAsync);
-    await testInMemoryDb(runAsync);
-    await testRestDb(runAsync);
+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) {
-    let args = new Map();
-    let params = url?.split('?')[1]?.split('&');
+    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)
-        for (const p of params) {
-            if (!p)
-                continue;
-            let z = p.split('=');
-            let key = decodeURIComponent(z[0]);
-            let value = decodeURIComponent(z[1]);
-            let x = args.get(key);
-            if (x === undefined) {
-                args.set(key, value);
+        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]);
             }
-            else if (Array.isArray(x))
-                x.push(value);
-            else
-                args.set(key, [args.get(key), value]);
         }
-    let req = {
-        get: (key) => {
-            let r = args.get(key);
+        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();
             }
@@ -146,72 +259,111 @@ function urlToReq(url) {
     };
     return req;
 }
-export class MockRestDataProvider {
-    constructor(remult) {
+var MockRestDataProvider = /** @class */ (function () {
+    function MockRestDataProvider(remult) {
         this.remult = remult;
         this.supportsCustomFilter = true;
     }
-    getEntityDataProvider(metadata) {
-        let dataApi = new DataApi(this.remult.repo(metadata.entityType), this.remult);
-        return new RestEntityDataProvider("", new HttpProviderBridgeToRestDataProviderHttpProvider({
-            delete: async (url) => {
-                let urlSplit = url.split('/');
-                let r = new TestDataApiResponse();
-                let result;
-                r.deleted = () => { };
-                try {
-                    testConfiguration.restDbRunningOnServer = true;
-                    await dataApi.delete(r, urlSplit[urlSplit.length - 1]);
-                }
-                finally {
-                    testConfiguration.restDbRunningOnServer = false;
-                }
-                return result;
-            },
-            get: async (url) => {
-                let r = new TestDataApiResponse();
-                let result;
-                r.success = data => { result = data; };
-                try {
-                    testConfiguration.restDbRunningOnServer = true;
-                    await dataApi.httpGet(r, urlToReq(url));
-                }
-                finally {
-                    testConfiguration.restDbRunningOnServer = false;
-                }
-                return result;
-            },
-            post: async (url, data) => {
-                let r = new TestDataApiResponse();
-                let result;
-                r.created = data => { result = data; };
-                r.success = data => { result = data; };
-                try {
-                    testConfiguration.restDbRunningOnServer = true;
-                    await dataApi.httpPost(r, urlToReq(url), data);
-                }
-                finally {
-                    testConfiguration.restDbRunningOnServer = false;
-                }
-                return result;
-            },
-            put: async (url, data) => {
-                let urlSplit = url.split('/');
-                let r = new TestDataApiResponse();
-                let result;
-                r.success = data => { result = data; };
-                try {
-                    testConfiguration.restDbRunningOnServer = true;
-                    await dataApi.put(r, urlSplit[urlSplit.length - 1], data);
-                }
-                finally {
-                    testConfiguration.restDbRunningOnServer = false;
-                }
-                return result;
-            }
+    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("", new context_1.HttpProviderBridgeToRestDataProviderHttpProvider({
+            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);
-    }
-    transaction(action) {
+    };
+    MockRestDataProvider.prototype.transaction = function (action) {
         throw new Error('Method not implemented.');
-    }
-}
+    };
+    return MockRestDataProvider;
+}());
+exports.MockRestDataProvider = MockRestDataProvider;

package/src/tests/testModel/models.js

@@ -1,31 +1,39 @@
-var Status_1, TestStatus_1;
-import { __decorate, __metadata } from "tslib";
-import { ValueListFieldType } from "../../remult3";
-let Status = Status_1 = class Status {
-    constructor(id, name) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestStatus = exports.Status = void 0;
+var tslib_1 = require("tslib");
+var remult3_1 = require("../../remult3");
+var Status = /** @class */ (function () {
+    function Status(id, name) {
         this.id = id;
         this.name = name;
     }
-};
-Status.open = new Status_1(0, "open");
-Status.closed = new Status_1(1, "closed");
-Status.hold = new Status_1(2, "hold");
-Status = Status_1 = __decorate([
-    ValueListFieldType(),
-    __metadata("design:paramtypes", [Number, String])
-], Status);
-export { Status };
-let TestStatus = TestStatus_1 = class TestStatus {
-    constructor(id, caption) {
+    Status_1 = Status;
+    var Status_1;
+    Status.open = new Status_1(0, "open");
+    Status.closed = new Status_1(1, "closed");
+    Status.hold = new Status_1(2, "hold");
+    Status = Status_1 = tslib_1.__decorate([
+        remult3_1.ValueListFieldType(),
+        tslib_1.__metadata("design:paramtypes", [Number, String])
+    ], Status);
+    return Status;
+}());
+exports.Status = Status;
+var TestStatus = /** @class */ (function () {
+    function TestStatus(id, caption) {
         this.id = id;
         this.caption = caption;
     }
-};
-TestStatus.open = new TestStatus_1();
-TestStatus.closed = new TestStatus_1('cc');
-TestStatus.hold = new TestStatus_1(undefined, 'hh');
-TestStatus = TestStatus_1 = __decorate([
-    ValueListFieldType(),
-    __metadata("design:paramtypes", [String, String])
-], TestStatus);
-export { TestStatus };
+    TestStatus_1 = TestStatus;
+    var TestStatus_1;
+    TestStatus.open = new TestStatus_1();
+    TestStatus.closed = new TestStatus_1('cc');
+    TestStatus.hold = new TestStatus_1(undefined, 'hh');
+    TestStatus = TestStatus_1 = tslib_1.__decorate([
+        remult3_1.ValueListFieldType(),
+        tslib_1.__metadata("design:paramtypes", [String, String])
+    ], TestStatus);
+    return TestStatus;
+}());
+exports.TestStatus = TestStatus;