remult 0.14.6 → 0.14.7

package/src/shared-tests/deleteAll.js

@@ -1,4 +1,21 @@
-export async function deleteAll(r) {
-    await Promise.all((await r.find()).map(x => r.delete(x)));
-    return r;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteAll = void 0;
+var tslib_1 = require("tslib");
+function deleteAll(r) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var _a, _b;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    _b = (_a = Promise).all;
+                    return [4 /*yield*/, r.find()];
+                case 1: return [4 /*yield*/, _b.apply(_a, [(_c.sent()).map(function (x) { return r.delete(x); })])];
+                case 2:
+                    _c.sent();
+                    return [2 /*return*/, r];
+            }
+        });
+    });
 }
+exports.deleteAll = deleteAll;

package/src/shared-tests/entityWithValidations.js

@@ -1,53 +1,80 @@
-var entityWithValidations_1;
-import { __decorate, __metadata } from "tslib";
-import { Remult } from '../context';
-import { Entity, EntityBase, Fields } from '../remult3';
-export var testConfiguration = { restDbRunningOnServer: false };
-let entityWithValidations = entityWithValidations_1 = class entityWithValidations extends EntityBase {
-    constructor(remult) {
-        super();
-        this.remult = remult;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.entityWithValidations = exports.testConfiguration = void 0;
+var tslib_1 = require("tslib");
+var context_1 = require("../context");
+var remult3_1 = require("../remult3");
+exports.testConfiguration = { restDbRunningOnServer: false };
+var entityWithValidations = /** @class */ (function (_super) {
+    tslib_1.__extends(entityWithValidations, _super);
+    function entityWithValidations(remult) {
+        var _this = _super.call(this) || this;
+        _this.remult = remult;
+        return _this;
     }
-    static async create4RowsInDp(createEntity) {
-        let s = await createEntity(entityWithValidations_1);
-        let c = s.create();
-        c.myId = 1;
-        c.name = 'noam';
-        await c._.save();
-        c = s.create();
-        c.myId = 2;
-        c.name = 'yael';
-        await c._.save();
-        c = s.create();
-        c.myId = 3;
-        c.name = 'yoni';
-        await c._.save();
-        c = s.create();
-        c.myId = 4;
-        c.name = 'maayan';
-        await c._.save();
-        return s;
-    }
-};
-entityWithValidations.savingRowCount = 0;
-__decorate([
-    Fields.integer(),
-    __metadata("design:type", Number)
-], entityWithValidations.prototype, "myId", void 0);
-__decorate([
-    Fields.string(),
-    __metadata("design:type", String)
-], entityWithValidations.prototype, "name", void 0);
-entityWithValidations = entityWithValidations_1 = __decorate([
-    Entity('', {
-        allowApiCrud: true,
-        saving: async (t) => {
-            if (!t.name || t.name.length < 3)
-                t._.fields.name.error = 'invalid';
-            if (!testConfiguration.restDbRunningOnServer)
-                entityWithValidations_1.savingRowCount++;
-        }
-    }),
-    __metadata("design:paramtypes", [Remult])
-], entityWithValidations);
-export { entityWithValidations };
+    entityWithValidations_1 = entityWithValidations;
+    entityWithValidations.create4RowsInDp = function (createEntity) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var s, c;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, createEntity(entityWithValidations_1)];
+                    case 1:
+                        s = _a.sent();
+                        c = s.create();
+                        c.myId = 1;
+                        c.name = 'noam';
+                        return [4 /*yield*/, c._.save()];
+                    case 2:
+                        _a.sent();
+                        c = s.create();
+                        c.myId = 2;
+                        c.name = 'yael';
+                        return [4 /*yield*/, c._.save()];
+                    case 3:
+                        _a.sent();
+                        c = s.create();
+                        c.myId = 3;
+                        c.name = 'yoni';
+                        return [4 /*yield*/, c._.save()];
+                    case 4:
+                        _a.sent();
+                        c = s.create();
+                        c.myId = 4;
+                        c.name = 'maayan';
+                        return [4 /*yield*/, c._.save()];
+                    case 5:
+                        _a.sent();
+                        return [2 /*return*/, s];
+                }
+            });
+        });
+    };
+    var entityWithValidations_1;
+    entityWithValidations.savingRowCount = 0;
+    tslib_1.__decorate([
+        remult3_1.Fields.integer(),
+        tslib_1.__metadata("design:type", Number)
+    ], entityWithValidations.prototype, "myId", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.string(),
+        tslib_1.__metadata("design:type", String)
+    ], entityWithValidations.prototype, "name", void 0);
+    entityWithValidations = entityWithValidations_1 = tslib_1.__decorate([
+        remult3_1.Entity('', {
+            allowApiCrud: true,
+            saving: function (t) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+                return tslib_1.__generator(this, function (_a) {
+                    if (!t.name || t.name.length < 3)
+                        t._.fields.name.error = 'invalid';
+                    if (!exports.testConfiguration.restDbRunningOnServer)
+                        entityWithValidations_1.savingRowCount++;
+                    return [2 /*return*/];
+                });
+            }); }
+        }),
+        tslib_1.__metadata("design:paramtypes", [context_1.Remult])
+    ], entityWithValidations);
+    return entityWithValidations;
+}(remult3_1.EntityBase));
+exports.entityWithValidations = entityWithValidations;

package/src/shared-tests/index.js

@@ -1,4 +1,6 @@
-import './db-tests.db-tests';
-import './test-custom-id-column.spec';
-import './test-special-value.spec';
-import './test-update-with-null.spec';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./db-tests.db-tests");
+require("./test-custom-id-column.spec");
+require("./test-special-value.spec");
+require("./test-update-with-null.spec");

package/src/shared-tests/test-custom-id-column.spec.js

@@ -1,41 +1,89 @@
-import { Entity, EntityBase, BuildEntity, Fields } from '../remult3';
-import { testAll } from './db-tests-setup';
-describe("custom id column", () => {
-    testAll("basic test", async ({ createEntity }) => {
-        let type = class extends EntityBase {
-        };
-        BuildEntity(type, 'custom', {
-            a: Fields.number(),
-            b: Fields.number()
-        }, { allowApiCrud: true });
-        let c = await createEntity(type);
-        let r = c.create();
-        r.a = 1;
-        r.b = 1;
-        await r._.save();
-        r = c.create();
-        r.a = 2;
-        r.b = 2;
-        await r._.save();
-        expect(c.metadata.idMetadata.field.key).toBe(c.metadata.fields.a.key);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var remult3_1 = require("../remult3");
+var db_tests_setup_1 = require("./db-tests-setup");
+describe("custom id column", function () {
+    db_tests_setup_1.testAll("basic test", function (_a) {
+        var createEntity = _a.createEntity;
+        return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+            var type, c, r;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        type = /** @class */ (function (_super) {
+                            tslib_1.__extends(class_1, _super);
+                            function class_1() {
+                                return _super !== null && _super.apply(this, arguments) || this;
+                            }
+                            return class_1;
+                        }(remult3_1.EntityBase));
+                        remult3_1.BuildEntity(type, 'custom', {
+                            a: remult3_1.Fields.number(),
+                            b: remult3_1.Fields.number()
+                        }, { allowApiCrud: true });
+                        return [4 /*yield*/, createEntity(type)];
+                    case 1:
+                        c = _b.sent();
+                        r = c.create();
+                        r.a = 1;
+                        r.b = 1;
+                        return [4 /*yield*/, r._.save()];
+                    case 2:
+                        _b.sent();
+                        r = c.create();
+                        r.a = 2;
+                        r.b = 2;
+                        return [4 /*yield*/, r._.save()];
+                    case 3:
+                        _b.sent();
+                        expect(c.metadata.idMetadata.field.key).toBe(c.metadata.fields.a.key);
+                        return [2 /*return*/];
+                }
+            });
+        });
     });
-    testAll("basic test id column not first column", async ({ createEntity }) => {
-        let type = class extends EntityBase {
-        };
-        Entity('custom2', { allowApiCrud: true })(type);
-        Fields.number()(type.prototype, 'a');
-        Fields.number()(type.prototype, 'id');
-        let c = await createEntity(type);
-        let r = c.create();
-        r.a = 1;
-        r.id = 5;
-        await r._.save();
-        r = c.create();
-        r.a = 2;
-        r.id = 6;
-        await r._.save();
-        expect(r._.repository.metadata.idMetadata.field.key).toBe(r._.fields.id.metadata.key);
-        expect((await c.findId(6)).a).toBe(2);
+    db_tests_setup_1.testAll("basic test id column not first column", function (_a) {
+        var createEntity = _a.createEntity;
+        return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+            var type, c, r, _b;
+            return tslib_1.__generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        type = /** @class */ (function (_super) {
+                            tslib_1.__extends(class_2, _super);
+                            function class_2() {
+                                return _super !== null && _super.apply(this, arguments) || this;
+                            }
+                            return class_2;
+                        }(remult3_1.EntityBase));
+                        remult3_1.Entity('custom2', { allowApiCrud: true })(type);
+                        remult3_1.Fields.number()(type.prototype, 'a');
+                        remult3_1.Fields.number()(type.prototype, 'id');
+                        return [4 /*yield*/, createEntity(type)];
+                    case 1:
+                        c = _c.sent();
+                        r = c.create();
+                        r.a = 1;
+                        r.id = 5;
+                        return [4 /*yield*/, r._.save()];
+                    case 2:
+                        _c.sent();
+                        r = c.create();
+                        r.a = 2;
+                        r.id = 6;
+                        return [4 /*yield*/, r._.save()];
+                    case 3:
+                        _c.sent();
+                        expect(r._.repository.metadata.idMetadata.field.key).toBe(r._.fields.id.metadata.key);
+                        _b = expect;
+                        return [4 /*yield*/, c.findId(6)];
+                    case 4:
+                        _b.apply(void 0, [(_c.sent()).a]).toBe(2);
+                        return [2 /*return*/];
+                }
+            });
+        });
     });
 });
 //typing game

package/src/shared-tests/test-special-value.spec.js

@@ -1,88 +1,128 @@
-var GroupsValue_1;
-import { __decorate, __metadata } from "tslib";
-import { Entity, EntityBase, Field, FieldType, Fields } from "../remult3";
-import { testAll } from "./db-tests-setup";
-let GroupsValue = GroupsValue_1 = class GroupsValue {
-    constructor(value) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupsValue = void 0;
+var tslib_1 = require("tslib");
+var remult3_1 = require("../remult3");
+var db_tests_setup_1 = require("./db-tests-setup");
+var GroupsValue = /** @class */ (function () {
+    function GroupsValue(value) {
         this.value = value;
     }
-    hasAny() {
+    GroupsValue_1 = GroupsValue;
+    GroupsValue.prototype.hasAny = function () {
         return this.value != '';
-    }
-    evilGet() {
+    };
+    GroupsValue.prototype.evilGet = function () {
         return this.value;
-    }
-    listGroups() {
+    };
+    GroupsValue.prototype.listGroups = function () {
         if (!this.value)
             return [];
         return this.value.split(',');
-    }
-    removeGroup(group) {
-        let groups = this.value.split(",").map(x => x.trim());
-        let index = groups.indexOf(group);
-        let result = '';
+    };
+    GroupsValue.prototype.removeGroup = function (group) {
+        var groups = this.value.split(",").map(function (x) { return x.trim(); });
+        var index = groups.indexOf(group);
+        var result = '';
         if (index >= 0) {
             groups.splice(index, 1);
             result = groups.join(", ");
         }
         return new GroupsValue_1(result);
-    }
-    addGroup(group) {
-        let r = this.value;
+    };
+    GroupsValue.prototype.addGroup = function (group) {
+        var r = this.value;
         if (r)
             r += ', ';
         else
             r = '';
         r += group;
         return new GroupsValue_1(r);
-    }
-    selected(group) {
+    };
+    GroupsValue.prototype.selected = function (group) {
         if (!this.value)
             return false;
         return this.value.indexOf(group) >= 0;
+    };
+    var GroupsValue_1;
+    GroupsValue = GroupsValue_1 = tslib_1.__decorate([
+        remult3_1.FieldType({
+            valueConverter: {
+                toJson: function (x) { return x ? x.value : ''; },
+                fromJson: function (x) { return new GroupsValue_1(x); },
+                displayValue: function (x) { return x.value; }
+            }
+        }),
+        tslib_1.__metadata("design:paramtypes", [String])
+    ], GroupsValue);
+    return GroupsValue;
+}());
+exports.GroupsValue = GroupsValue;
+var testGroups = /** @class */ (function (_super) {
+    tslib_1.__extends(testGroups, _super);
+    function testGroups() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.id = 0;
+        return _this;
     }
-};
-GroupsValue = GroupsValue_1 = __decorate([
-    FieldType({
-        valueConverter: {
-            toJson: x => x ? x.value : '',
-            fromJson: x => new GroupsValue_1(x),
-            displayValue: x => x.value
-        }
-    }),
-    __metadata("design:paramtypes", [String])
-], GroupsValue);
-export { GroupsValue };
-let testGroups = class testGroups extends EntityBase {
-    constructor() {
-        super(...arguments);
-        this.id = 0;
-    }
-};
-__decorate([
-    Fields.integer(),
-    __metadata("design:type", Number)
-], testGroups.prototype, "id", void 0);
-__decorate([
-    Field(() => GroupsValue),
-    __metadata("design:type", GroupsValue)
-], testGroups.prototype, "g", void 0);
-testGroups = __decorate([
-    Entity("testGroups", { allowApiCrud: true })
-], testGroups);
-testAll("test save and load", async ({ createEntity }) => {
-    let re = await createEntity(testGroups);
-    await re.create({ id: 1 }).save();
-    let x = await re.findFirst();
-    expect(x.g.evilGet()).toBe('');
-    x.g = x.g.addGroup("xx");
-    expect(x.$.g.valueChanged()).toBe(true);
-    await x.save();
-    expect(x.g.evilGet()).toBe('xx');
+    tslib_1.__decorate([
+        remult3_1.Fields.integer(),
+        tslib_1.__metadata("design:type", Number)
+    ], testGroups.prototype, "id", void 0);
+    tslib_1.__decorate([
+        remult3_1.Field(function () { return GroupsValue; }),
+        tslib_1.__metadata("design:type", GroupsValue)
+    ], testGroups.prototype, "g", void 0);
+    testGroups = tslib_1.__decorate([
+        remult3_1.Entity("testGroups", { allowApiCrud: true })
+    ], testGroups);
+    return testGroups;
+}(remult3_1.EntityBase));
+db_tests_setup_1.testAll("test save and load", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var re, x;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, createEntity(testGroups)];
+                case 1:
+                    re = _b.sent();
+                    return [4 /*yield*/, re.create({ id: 1 }).save()];
+                case 2:
+                    _b.sent();
+                    return [4 /*yield*/, re.findFirst()];
+                case 3:
+                    x = _b.sent();
+                    expect(x.g.evilGet()).toBe('');
+                    x.g = x.g.addGroup("xx");
+                    expect(x.$.g.valueChanged()).toBe(true);
+                    return [4 /*yield*/, x.save()];
+                case 4:
+                    _b.sent();
+                    expect(x.g.evilGet()).toBe('xx');
+                    return [2 /*return*/];
+            }
+        });
+    });
 });
-testAll("test2 save and load", async ({ createEntity }) => {
-    let re = await createEntity(testGroups);
-    await re.create({ id: 1, g: new GroupsValue(undefined) }).save();
-    let x = await re.findFirst();
-    expect(x.g.evilGet()).toBe('');
+db_tests_setup_1.testAll("test2 save and load", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var re, x;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, createEntity(testGroups)];
+                case 1:
+                    re = _b.sent();
+                    return [4 /*yield*/, re.create({ id: 1, g: new GroupsValue(undefined) }).save()];
+                case 2:
+                    _b.sent();
+                    return [4 /*yield*/, re.findFirst()];
+                case 3:
+                    x = _b.sent();
+                    expect(x.g.evilGet()).toBe('');
+                    return [2 /*return*/];
+            }
+        });
+    });
 });

package/src/shared-tests/test-update-with-null.spec.js

@@ -1,30 +1,51 @@
-import { __decorate, __metadata } from "tslib";
-import { Entity, EntityBase, Field, Fields } from "../remult3";
-import { testAll } from "./db-tests-setup";
-let testNull = class testNull extends EntityBase {
-    constructor() {
-        super(...arguments);
-        this.id = 0;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var remult3_1 = require("../remult3");
+var db_tests_setup_1 = require("./db-tests-setup");
+var testNull = /** @class */ (function (_super) {
+    tslib_1.__extends(testNull, _super);
+    function testNull() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.id = 0;
+        return _this;
     }
-};
-__decorate([
-    Fields.integer(),
-    __metadata("design:type", Number)
-], testNull.prototype, "id", void 0);
-__decorate([
-    Field(undefined, { allowNull: true }),
-    __metadata("design:type", Object)
-], testNull.prototype, "myCol", void 0);
-testNull = __decorate([
-    Entity('testNull', { allowApiCrud: true })
-], testNull);
-testAll("test that update null works", async ({ createEntity }) => {
-    let r = await createEntity(testNull);
-    let i = r.create({ id: 1, myCol: { value: 'abc' } });
-    await i.save();
-    expect(i.myCol?.value).toBe("abc");
-    i.myCol = null;
-    expect(i.myCol).toBe(null);
-    await i.save();
-    expect(i.myCol).toBe(null);
+    tslib_1.__decorate([
+        remult3_1.Fields.integer(),
+        tslib_1.__metadata("design:type", Number)
+    ], testNull.prototype, "id", void 0);
+    tslib_1.__decorate([
+        remult3_1.Field(undefined, { allowNull: true }),
+        tslib_1.__metadata("design:type", Object)
+    ], testNull.prototype, "myCol", void 0);
+    testNull = tslib_1.__decorate([
+        remult3_1.Entity('testNull', { allowApiCrud: true })
+    ], testNull);
+    return testNull;
+}(remult3_1.EntityBase));
+db_tests_setup_1.testAll("test that update null works", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var r, i;
+        var _b;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, createEntity(testNull)];
+                case 1:
+                    r = _c.sent();
+                    i = r.create({ id: 1, myCol: { value: 'abc' } });
+                    return [4 /*yield*/, i.save()];
+                case 2:
+                    _c.sent();
+                    expect((_b = i.myCol) === null || _b === void 0 ? void 0 : _b.value).toBe("abc");
+                    i.myCol = null;
+                    expect(i.myCol).toBe(null);
+                    return [4 /*yield*/, i.save()];
+                case 3:
+                    _c.sent();
+                    expect(i.myCol).toBe(null);
+                    return [2 /*return*/];
+            }
+        });
+    });
 }, false);