remult 0.14.6 → 0.14.7

package/src/sort.js

@@ -1,82 +1,139 @@
-import { CompoundIdField } from "./column";
-export class Sort {
-    constructor(...segments) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sort = void 0;
+var tslib_1 = require("tslib");
+var column_1 = require("./column");
+var Sort = /** @class */ (function () {
+    function Sort() {
+        var segments = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            segments[_i] = arguments[_i];
+        }
         this.Segments = segments;
     }
-    toEntityOrderBy() {
-        let result = {};
-        for (const seg of this.Segments) {
-            if (seg.isDescending) {
-                result[seg.field.key] = "desc";
+    Sort.prototype.toEntityOrderBy = function () {
+        var e_1, _a;
+        var result = {};
+        try {
+            for (var _b = tslib_1.__values(this.Segments), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var seg = _c.value;
+                if (seg.isDescending) {
+                    result[seg.field.key] = "desc";
+                }
+                else
+                    result[seg.field.key] = "asc";
             }
-            else
-                result[seg.field.key] = "asc";
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
         }
         return result;
-    }
-    reverse() {
-        let r = new Sort();
-        for (const s of this.Segments) {
-            r.Segments.push({ field: s.field, isDescending: !s.isDescending });
+    };
+    Sort.prototype.reverse = function () {
+        var e_2, _a;
+        var r = new Sort();
+        try {
+            for (var _b = tslib_1.__values(this.Segments), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var s = _c.value;
+                r.Segments.push({ field: s.field, isDescending: !s.isDescending });
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_2) throw e_2.error; }
         }
         return r;
-    }
-    static translateOrderByToSort(entityDefs, orderBy) {
+    };
+    Sort.translateOrderByToSort = function (entityDefs, orderBy) {
         if (!orderBy)
             return undefined;
-        let sort;
+        var sort;
         if (orderBy) {
             sort = new Sort();
-            for (const key in orderBy) {
+            for (var key in orderBy) {
                 if (Object.prototype.hasOwnProperty.call(orderBy, key)) {
-                    const element = orderBy[key];
-                    let field = entityDefs.fields.find(key);
+                    var element = orderBy[key];
+                    var field = entityDefs.fields.find(key);
                     if (field) {
                         switch (element) {
                             case "desc":
-                                sort.Segments.push({ field, isDescending: true });
+                                sort.Segments.push({ field: field, isDescending: true });
                                 break;
                             case "asc":
-                                sort.Segments.push({ field });
+                                sort.Segments.push({ field: field });
                         }
                     }
                 }
             }
         }
         return sort;
-    }
-    static createUniqueSort(entityMetadata, orderBy) {
+    };
+    Sort.createUniqueSort = function (entityMetadata, orderBy) {
+        var e_3, _a;
         if (!orderBy || Object.keys(orderBy).length === 0)
             orderBy = Sort.translateOrderByToSort(entityMetadata, entityMetadata.options.defaultOrderBy);
         if (!orderBy)
             orderBy = new Sort({ field: entityMetadata.idMetadata.field });
-        if (entityMetadata.idMetadata.field instanceof CompoundIdField) {
-            for (const field of entityMetadata.idMetadata.field.fields) {
-                if (!orderBy.Segments.find(x => x.field == field)) {
+        if (entityMetadata.idMetadata.field instanceof column_1.CompoundIdField) {
+            var _loop_1 = function (field) {
+                if (!orderBy.Segments.find(function (x) { return x.field == field; })) {
                     orderBy.Segments.push({ field: field });
                 }
+            };
+            try {
+                for (var _b = tslib_1.__values(entityMetadata.idMetadata.field.fields), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var field = _c.value;
+                    _loop_1(field);
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_3) throw e_3.error; }
             }
         }
-        else if (!orderBy.Segments.find(x => x.field == entityMetadata.idMetadata.field)) {
+        else if (!orderBy.Segments.find(function (x) { return x.field == entityMetadata.idMetadata.field; })) {
             orderBy.Segments.push({ field: entityMetadata.idMetadata.field });
         }
         return orderBy;
-    }
-    static createUniqueEntityOrderBy(entityMetadata, orderBy) {
+    };
+    Sort.createUniqueEntityOrderBy = function (entityMetadata, orderBy) {
+        var _a, e_4, _b;
         if (!orderBy || Object.keys(orderBy).length === 0)
             orderBy = entityMetadata.options.defaultOrderBy;
         if (!orderBy)
-            orderBy = { [entityMetadata.idMetadata.field.key]: "asc" };
-        if (entityMetadata.idMetadata.field instanceof CompoundIdField) {
-            for (const field of entityMetadata.idMetadata.field.fields) {
-                if (!orderBy[field.key]) {
-                    orderBy[field.key] = "asc";
+            orderBy = (_a = {}, _a[entityMetadata.idMetadata.field.key] = "asc", _a);
+        if (entityMetadata.idMetadata.field instanceof column_1.CompoundIdField) {
+            try {
+                for (var _c = tslib_1.__values(entityMetadata.idMetadata.field.fields), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var field = _d.value;
+                    if (!orderBy[field.key]) {
+                        orderBy[field.key] = "asc";
+                    }
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
                 }
+                finally { if (e_4) throw e_4.error; }
             }
         }
         else if (!orderBy[entityMetadata.idMetadata.field.key]) {
             orderBy[entityMetadata.idMetadata.field.key] = "asc";
         }
         return orderBy;
-    }
-}
+    };
+    return Sort;
+}());
+exports.Sort = Sort;

package/src/sql-command.js

@@ -1 +1,2 @@
-export {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/tests/Done.js

@@ -1,11 +1,17 @@
-export class Done {
-    constructor() {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Done = void 0;
+var Done = /** @class */ (function () {
+    function Done() {
         this.happened = false;
     }
-    ok() {
+    Done.prototype.ok = function () {
         this.happened = true;
-    }
-    test(message = 'expected to be done') {
+    };
+    Done.prototype.test = function (message) {
+        if (message === void 0) { message = 'expected to be done'; }
         expect(this.happened).toBe(true, message);
-    }
-}
+    };
+    return Done;
+}());
+exports.Done = Done;

package/src/tests/TestDataApiResponse.js

@@ -1,22 +1,29 @@
-export class TestDataApiResponse {
-    progress(progress) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestDataApiResponse = void 0;
+var TestDataApiResponse = /** @class */ (function () {
+    function TestDataApiResponse() {
     }
-    success(data) {
+    TestDataApiResponse.prototype.progress = function (progress) {
+    };
+    TestDataApiResponse.prototype.success = function (data) {
         throw new Error(('didnt expect success: ' + JSON.stringify(data)));
-    }
-    forbidden() {
+    };
+    TestDataApiResponse.prototype.forbidden = function () {
         throw new Error('didnt expect forbidden:');
-    }
-    created(data) {
+    };
+    TestDataApiResponse.prototype.created = function (data) {
         throw new Error('didnt expect created: ' + JSON.stringify(data));
-    }
-    deleted() {
+    };
+    TestDataApiResponse.prototype.deleted = function () {
         throw new Error('didnt expect deleted:');
-    }
-    notFound() {
+    };
+    TestDataApiResponse.prototype.notFound = function () {
         throw new Error('not found');
-    }
-    error(data) {
+    };
+    TestDataApiResponse.prototype.error = function (data) {
         throw new Error('error: ' + data + " " + JSON.stringify(data));
-    }
-}
+    };
+    return TestDataApiResponse;
+}());
+exports.TestDataApiResponse = TestDataApiResponse;

package/src/tests/c.js

@@ -1,22 +1,28 @@
-import { __decorate, __metadata } from "tslib";
-import { Remult } from '../context';
-import { Entity, EntityBase, Fields } from '../remult3';
-let c = class c extends EntityBase {
-    constructor(remult) {
-        super();
-        this.remult = remult;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.c = void 0;
+var tslib_1 = require("tslib");
+var context_1 = require("../context");
+var remult3_1 = require("../remult3");
+var c = /** @class */ (function (_super) {
+    tslib_1.__extends(c, _super);
+    function c(remult) {
+        var _this = _super.call(this) || this;
+        _this.remult = remult;
+        return _this;
     }
-};
-__decorate([
-    Fields.integer(),
-    __metadata("design:type", Number)
-], c.prototype, "id", void 0);
-__decorate([
-    Fields.string(),
-    __metadata("design:type", String)
-], c.prototype, "name", void 0);
-c = __decorate([
-    Entity('c', { allowApiCrud: true }),
-    __metadata("design:paramtypes", [Remult])
-], c);
-export { c };
+    tslib_1.__decorate([
+        remult3_1.Fields.integer(),
+        tslib_1.__metadata("design:type", Number)
+    ], c.prototype, "id", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.string(),
+        tslib_1.__metadata("design:type", String)
+    ], c.prototype, "name", void 0);
+    c = tslib_1.__decorate([
+        remult3_1.Entity('c', { allowApiCrud: true }),
+        tslib_1.__metadata("design:paramtypes", [context_1.Remult])
+    ], c);
+    return c;
+}(remult3_1.EntityBase));
+exports.c = c;

package/src/tests/createData.js

@@ -1,22 +1,50 @@
-import { InMemoryDataProvider } from '../data-providers/in-memory-database';
-import { Remult } from '../context';
-import { Categories as newCategories } from './remult-3-entities';
-import { deleteAll } from '../shared-tests/deleteAll';
-export async function createData(doInsert, entity) {
-    let remult = new Remult();
-    remult.setDataProvider(new InMemoryDataProvider());
-    if (!entity)
-        entity = newCategories;
-    let rep = await deleteAll(remult.repo(entity));
-    if (doInsert)
-        await doInsert(async (id, name, description, status) => {
-            let c = rep.create();
-            c.id = id;
-            c.categoryName = name;
-            c.description = description;
-            if (status)
-                c.status = status;
-            await rep.save(c);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createData = void 0;
+var tslib_1 = require("tslib");
+var in_memory_database_1 = require("../data-providers/in-memory-database");
+var context_1 = require("../context");
+var remult_3_entities_1 = require("./remult-3-entities");
+var deleteAll_1 = require("../shared-tests/deleteAll");
+function createData(doInsert, entity) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var remult, rep;
+        var _this = this;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    remult = new context_1.Remult();
+                    remult.setDataProvider(new in_memory_database_1.InMemoryDataProvider());
+                    if (!entity)
+                        entity = remult_3_entities_1.Categories;
+                    return [4 /*yield*/, deleteAll_1.deleteAll(remult.repo(entity))];
+                case 1:
+                    rep = _a.sent();
+                    if (!doInsert) return [3 /*break*/, 3];
+                    return [4 /*yield*/, doInsert(function (id, name, description, status) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                            var c;
+                            return tslib_1.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        c = rep.create();
+                                        c.id = id;
+                                        c.categoryName = name;
+                                        c.description = description;
+                                        if (status)
+                                            c.status = status;
+                                        return [4 /*yield*/, rep.save(c)];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); })];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3: return [2 /*return*/, [rep, remult]];
+            }
         });
-    return [rep, remult];
+    });
 }
+exports.createData = createData;

package/src/tests/d.js

@@ -1,19 +1,27 @@
-import { __decorate, __metadata } from "tslib";
-import { Entity, EntityBase, Fields } from '../remult3';
-let d = class d extends EntityBase {
-};
-d.count = 0;
-__decorate([
-    Fields.integer(),
-    __metadata("design:type", Number)
-], d.prototype, "id", void 0);
-__decorate([
-    Fields.integer(),
-    __metadata("design:type", Number)
-], d.prototype, "b", void 0);
-d = __decorate([
-    Entity('d1', {
-        allowApiCrud: true
-    })
-], d);
-export { d };
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.d = void 0;
+var tslib_1 = require("tslib");
+var remult3_1 = require("../remult3");
+var d = /** @class */ (function (_super) {
+    tslib_1.__extends(d, _super);
+    function d() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    d.count = 0;
+    tslib_1.__decorate([
+        remult3_1.Fields.integer(),
+        tslib_1.__metadata("design:type", Number)
+    ], d.prototype, "id", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.integer(),
+        tslib_1.__metadata("design:type", Number)
+    ], d.prototype, "b", void 0);
+    d = tslib_1.__decorate([
+        remult3_1.Entity('d1', {
+            allowApiCrud: true
+        })
+    ], d);
+    return d;
+}(remult3_1.EntityBase));
+exports.d = d;

package/src/tests/dWithPrefilter.js

@@ -1,32 +1,45 @@
-var dWithPrefilter_1;
-import { __decorate, __metadata } from "tslib";
-import { BackendMethod } from '../server-action';
-import { Entity, EntityBase, Fields } from '../remult3';
-let dWithPrefilter = dWithPrefilter_1 = class dWithPrefilter extends EntityBase {
-    async doIt() {
-        dWithPrefilter_1.count++;
-        return true;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dWithPrefilter = void 0;
+var tslib_1 = require("tslib");
+var server_action_1 = require("../server-action");
+var remult3_1 = require("../remult3");
+var dWithPrefilter = /** @class */ (function (_super) {
+    tslib_1.__extends(dWithPrefilter, _super);
+    function dWithPrefilter() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
-};
-dWithPrefilter.count = 0;
-__decorate([
-    Fields.integer(),
-    __metadata("design:type", Number)
-], dWithPrefilter.prototype, "id", void 0);
-__decorate([
-    Fields.integer(),
-    __metadata("design:type", Number)
-], dWithPrefilter.prototype, "b", void 0);
-__decorate([
-    BackendMethod({ allowed: true }),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Promise)
-], dWithPrefilter.prototype, "doIt", null);
-dWithPrefilter = dWithPrefilter_1 = __decorate([
-    Entity('d', {
-        apiPrefilter: { b: 2 },
-        allowApiCrud: true
-    })
-], dWithPrefilter);
-export { dWithPrefilter };
+    dWithPrefilter_1 = dWithPrefilter;
+    dWithPrefilter.prototype.doIt = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                dWithPrefilter_1.count++;
+                return [2 /*return*/, true];
+            });
+        });
+    };
+    var dWithPrefilter_1;
+    dWithPrefilter.count = 0;
+    tslib_1.__decorate([
+        remult3_1.Fields.integer(),
+        tslib_1.__metadata("design:type", Number)
+    ], dWithPrefilter.prototype, "id", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.integer(),
+        tslib_1.__metadata("design:type", Number)
+    ], dWithPrefilter.prototype, "b", void 0);
+    tslib_1.__decorate([
+        server_action_1.BackendMethod({ allowed: true }),
+        tslib_1.__metadata("design:type", Function),
+        tslib_1.__metadata("design:paramtypes", []),
+        tslib_1.__metadata("design:returntype", Promise)
+    ], dWithPrefilter.prototype, "doIt", null);
+    dWithPrefilter = dWithPrefilter_1 = tslib_1.__decorate([
+        remult3_1.Entity('d', {
+            apiPrefilter: { b: 2 },
+            allowApiCrud: true
+        })
+    ], dWithPrefilter);
+    return dWithPrefilter;
+}(remult3_1.EntityBase));
+exports.dWithPrefilter = dWithPrefilter;

package/src/tests/entityForCustomFilter.js

@@ -1,44 +1,68 @@
-var entityForCustomFilter_1;
-import { __decorate, __metadata } from "tslib";
-import { SqlDatabase } from '../data-providers/sql-database';
-import { Entity, EntityBase, Fields } from '../remult3';
-import { Filter } from '../filter/filter-interfaces';
-import { ArrayEntityDataProvider } from '../data-providers/array-entity-data-provider';
-import { getDbNameProvider } from '../filter/filter-consumer-bridge-to-sql-request';
-let entityForCustomFilter = entityForCustomFilter_1 = class entityForCustomFilter extends EntityBase {
-};
-entityForCustomFilter.filter = Filter.createCustom(async (remult, c) => {
-    let r = [];
-    if (c.oneAndThree)
-        r.push({ id: [1, 3] });
-    if (c.two)
-        r.push({ id: 2 });
-    if (c.dbOneOrThree) {
-        let meta = remult.repo(entityForCustomFilter_1).metadata;
-        const e = await getDbNameProvider(meta);
-        r.push({
-            $and: [
-                SqlDatabase.customFilter(async (x) => x.sql = e.nameOf(meta.fields.id) + ' in (' + x.addParameterAndReturnSqlToken(1) + "," + x.addParameterAndReturnSqlToken(3) + ")"),
-                ArrayEntityDataProvider.customFilter(x => x.id == 1 || x.id == 3)
-            ]
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.entityForCustomFilter1 = exports.entityForCustomFilter = void 0;
+var tslib_1 = require("tslib");
+var sql_database_1 = require("../data-providers/sql-database");
+var remult3_1 = require("../remult3");
+var filter_interfaces_1 = require("../filter/filter-interfaces");
+var array_entity_data_provider_1 = require("../data-providers/array-entity-data-provider");
+var filter_consumer_bridge_to_sql_request_1 = require("../filter/filter-consumer-bridge-to-sql-request");
+var entityForCustomFilter = /** @class */ (function (_super) {
+    tslib_1.__extends(entityForCustomFilter, _super);
+    function entityForCustomFilter() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    entityForCustomFilter_1 = entityForCustomFilter;
+    var entityForCustomFilter_1;
+    entityForCustomFilter.filter = filter_interfaces_1.Filter.createCustom(function (remult, c) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var r, meta_1, e_1;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    r = [];
+                    if (c.oneAndThree)
+                        r.push({ id: [1, 3] });
+                    if (c.two)
+                        r.push({ id: 2 });
+                    if (!c.dbOneOrThree) return [3 /*break*/, 2];
+                    meta_1 = remult.repo(entityForCustomFilter_1).metadata;
+                    return [4 /*yield*/, filter_consumer_bridge_to_sql_request_1.getDbNameProvider(meta_1)];
+                case 1:
+                    e_1 = _a.sent();
+                    r.push({
+                        $and: [
+                            sql_database_1.SqlDatabase.customFilter(function (x) { return tslib_1.__awaiter(void 0, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
+                                return [2 /*return*/, x.sql = e_1.nameOf(meta_1.fields.id) + ' in (' + x.addParameterAndReturnSqlToken(1) + "," + x.addParameterAndReturnSqlToken(3) + ")"];
+                            }); }); }),
+                            array_entity_data_provider_1.ArrayEntityDataProvider.customFilter(function (x) { return x.id == 1 || x.id == 3; })
+                        ]
+                    });
+                    _a.label = 2;
+                case 2: return [2 /*return*/, { $and: r }];
+            }
         });
+    }); });
+    entityForCustomFilter.oneAndThree = filter_interfaces_1.Filter.createCustom(function () { return ({ id: [1, 3] }); });
+    entityForCustomFilter.testNumericValue = filter_interfaces_1.Filter.createCustom(function (r, val) { return ({ id: val }); });
+    entityForCustomFilter.testObjectValue = filter_interfaces_1.Filter.createCustom(function (r, val) { return ({ id: val.val }); });
+    tslib_1.__decorate([
+        remult3_1.Fields.integer(),
+        tslib_1.__metadata("design:type", Number)
+    ], entityForCustomFilter.prototype, "id", void 0);
+    entityForCustomFilter = entityForCustomFilter_1 = tslib_1.__decorate([
+        remult3_1.Entity('entityForCustomFilter', { allowApiCrud: true })
+    ], entityForCustomFilter);
+    return entityForCustomFilter;
+}(remult3_1.EntityBase));
+exports.entityForCustomFilter = entityForCustomFilter;
+var entityForCustomFilter1 = /** @class */ (function (_super) {
+    tslib_1.__extends(entityForCustomFilter1, _super);
+    function entityForCustomFilter1() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
-    return { $and: r };
-});
-entityForCustomFilter.oneAndThree = Filter.createCustom(() => ({ id: [1, 3] }));
-entityForCustomFilter.testNumericValue = Filter.createCustom((r, val) => ({ id: val }));
-entityForCustomFilter.testObjectValue = Filter.createCustom((r, val) => ({ id: val.val }));
-__decorate([
-    Fields.integer(),
-    __metadata("design:type", Number)
-], entityForCustomFilter.prototype, "id", void 0);
-entityForCustomFilter = entityForCustomFilter_1 = __decorate([
-    Entity('entityForCustomFilter', { allowApiCrud: true })
-], entityForCustomFilter);
-export { entityForCustomFilter };
-let entityForCustomFilter1 = class entityForCustomFilter1 extends entityForCustomFilter {
-};
-entityForCustomFilter1 = __decorate([
-    Entity('entityForCustomFilter1', { allowApiCrud: true })
-], entityForCustomFilter1);
-export { entityForCustomFilter1 };
+    entityForCustomFilter1 = tslib_1.__decorate([
+        remult3_1.Entity('entityForCustomFilter1', { allowApiCrud: true })
+    ], entityForCustomFilter1);
+    return entityForCustomFilter1;
+}(entityForCustomFilter));
+exports.entityForCustomFilter1 = entityForCustomFilter1;