remult 0.22.1 → 0.22.3

package/src/backend-tests/backend-database-test-setup.backend-spec.js

@@ -92,6 +92,16 @@ exports.mySqlTest = db_tests_setup_1.addDatabaseToTest(testKnexSqlImpl(Knex.defa
         database: 'test',
     },
 }), 'mysql2'));
+db_tests_setup_1.addDatabaseToTest(testKnexSqlImpl(Knex.default({
+    client: 'mysql',
+    connection: {
+        user: 'root',
+        password: 'MASTERKEY',
+        host: '127.0.0.1',
+        database: 'test',
+        port: 3307
+    },
+}), 'mysql'));
 var pg = postgres_1.createPostgresConnection();
 function testPostgresImplementation(key, what, focus) {
     var _this = this;
@@ -390,4 +400,54 @@ exports.testMongoNoTrans('transactions mongo no trans', function (_a) {
         });
     });
 }, false);
+exports.testMongoNoTrans('test Dates', function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var c, r, x, client, mongoDb, _b, _c, _d, _e, _f, _g;
+        return tslib_1.__generator(this, function (_h) {
+            switch (_h.label) {
+                case 0:
+                    c = /** @class */ (function () {
+                        function class_2() {
+                        }
+                        return class_2;
+                    }());
+                    DecoratorReplacer_1.describeClass(c, remult3_1.Entity('test_dates_on_mongo'), {
+                        id: remult3_1.Fields.integer(),
+                        date: remult3_1.Fields.date(),
+                    });
+                    return [4 /*yield*/, createEntity(c)];
+                case 1:
+                    r = _h.sent();
+                    return [4 /*yield*/, r.insert({ id: 1, date: new Date(1976, 5, 16) })];
+                case 2:
+                    x = _h.sent();
+                    client = new mongodb_1.MongoClient('mongodb://localhost:27017/local');
+                    return [4 /*yield*/, client.connect()];
+                case 3:
+                    _h.sent();
+                    mongoDb = client.db('test');
+                    _b = expect;
+                    _d = (_c = mongoDb).collection;
+                    return [4 /*yield*/, r.metadata.getDbName()];
+                case 4: return [4 /*yield*/, _d.apply(_c, [_h.sent()]).findOne()];
+                case 5:
+                    _b.apply(void 0, [(_h.sent())
+                            .date instanceof Date]).toBe(true);
+                    x.date = new Date(1978, 2, 15);
+                    return [4 /*yield*/, r.save(x)];
+                case 6:
+                    _h.sent();
+                    _e = expect;
+                    _g = (_f = mongoDb).collection;
+                    return [4 /*yield*/, r.metadata.getDbName()];
+                case 7: return [4 /*yield*/, _g.apply(_f, [_h.sent()]).findOne()];
+                case 8:
+                    _e.apply(void 0, [(_h.sent())
+                            .date instanceof Date]).toBe(true);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}, false);
 require("../shared-tests");

package/{esm/core/src → src}/backend-tests/my-test.backend-spec.d.ts

@@ -1 +1 @@
-export {};
+export {};

package/src/backend-tests/my-test.backend-spec.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var context_1 = require("../context");
+var remult_knex_1 = require("../../remult-knex");
+var dotenv_1 = require("dotenv");
+var backend_database_test_setup_backend_spec_1 = require("./backend-database-test-setup.backend-spec");
+var entityWithValidations_1 = require("../shared-tests/entityWithValidations");
+var sql_database_1 = require("../data-providers/sql-database");
+var expressBridge_1 = require("../../server/expressBridge");
+var initAsyncHooks_1 = require("../../server/initAsyncHooks");
+var remult_proxy_1 = require("../remult-proxy");
+dotenv_1.config();
+backend_database_test_setup_backend_spec_1.testPostgresImplementation("default order by", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var s, _b;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, entityWithValidations_1.entityWithValidations.create4RowsInDp(createEntity)];
+                case 1:
+                    s = _c.sent();
+                    return [4 /*yield*/, s.update(1, { name: "updated name" })];
+                case 2:
+                    _c.sent();
+                    _b = expect;
+                    return [4 /*yield*/, s.find()];
+                case 3:
+                    _b.apply(void 0, [(_c.sent()).map(function (x) { return x.myId; })]).toEqual([1, 2, 3, 4]);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}, false);
+backend_database_test_setup_backend_spec_1.testKnexPGSqlImpl("default order by", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var s, _b;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, entityWithValidations_1.entityWithValidations.create4RowsInDp(createEntity)];
+                case 1:
+                    s = _c.sent();
+                    return [4 /*yield*/, s.update(1, { name: "updated name" })];
+                case 2:
+                    _c.sent();
+                    _b = expect;
+                    return [4 /*yield*/, s.find()];
+                case 3:
+                    _b.apply(void 0, [(_c.sent()).map(function (x) { return x.myId; })]).toEqual([1, 2, 3, 4]);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}, false);
+backend_database_test_setup_backend_spec_1.testPostgresImplementation("sql filter", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var s, _b;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, entityWithValidations_1.entityWithValidations.create4RowsInDp(createEntity)];
+                case 1:
+                    s = _c.sent();
+                    _b = expect;
+                    return [4 /*yield*/, s.find({
+                            where: sql_database_1.SqlDatabase.customFilter(function (build) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+                                return tslib_1.__generator(this, function (_a) {
+                                    build.sql = s.metadata.fields.myId.options.dbName + ' in (1,3)';
+                                    return [2 /*return*/];
+                                });
+                            }); })
+                        })];
+                case 2:
+                    _b.apply(void 0, [(_c.sent()).length]).toBe(2);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}, false);
+backend_database_test_setup_backend_spec_1.testPostgresImplementation("sql filter2", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var s, _b;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, entityWithValidations_1.entityWithValidations.create4RowsInDp(createEntity)];
+                case 1:
+                    s = _c.sent();
+                    _b = expect;
+                    return [4 /*yield*/, s.find({
+                            where: {
+                                $or: [
+                                    sql_database_1.SqlDatabase.customFilter(function (build) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+                                        return tslib_1.__generator(this, function (_a) {
+                                            build.sql = s.metadata.fields.myId.options.dbName + ' in (1,3)';
+                                            return [2 /*return*/];
+                                        });
+                                    }); }),
+                                    {
+                                        myId: 2
+                                    }
+                                ]
+                            }
+                        })];
+                case 2:
+                    _b.apply(void 0, [(_c.sent()).length]).toBe(3);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}, false);
+backend_database_test_setup_backend_spec_1.testKnexPGSqlImpl("knex filter", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var s, _b;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, entityWithValidations_1.entityWithValidations.create4RowsInDp(createEntity)];
+                case 1:
+                    s = _c.sent();
+                    _b = expect;
+                    return [4 /*yield*/, s.find({
+                            where: remult_knex_1.KnexDataProvider.customFilter(function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+                                return tslib_1.__generator(this, function (_a) {
+                                    return [2 /*return*/, function (build) { return build.whereIn(s.metadata.fields.myId.options.dbName, [1, 3]); }];
+                                });
+                            }); })
+                        })];
+                case 2:
+                    _b.apply(void 0, [(_c.sent()).length]).toBe(2);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}, false);
+backend_database_test_setup_backend_spec_1.testKnexPGSqlImpl("knex filter2", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var s, _b;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, entityWithValidations_1.entityWithValidations.create4RowsInDp(createEntity)];
+                case 1:
+                    s = _c.sent();
+                    _b = expect;
+                    return [4 /*yield*/, s.find({
+                            where: {
+                                $or: [remult_knex_1.KnexDataProvider.customFilter(function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+                                        return tslib_1.__generator(this, function (_a) {
+                                            return [2 /*return*/, function (build) { return build.whereIn(s.metadata.fields.myId.options.dbName, [1, 3]); }];
+                                        });
+                                    }); }), {
+                                        myId: 4
+                                    }]
+                            }
+                        })];
+                case 2:
+                    _b.apply(void 0, [(_c.sent()).length]).toBe(3);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}, false);
+it("test async hooks and static remult", function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+    var gotException, promises;
+    return tslib_1.__generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                gotException = true;
+                try {
+                    expressBridge_1.RemultAsyncLocalStorage.instance.getRemult();
+                    gotException = false;
+                }
+                catch (_b) { }
+                expect(gotException).toBe(true);
+                initAsyncHooks_1.initAsyncHooks();
+                expect(expressBridge_1.RemultAsyncLocalStorage.instance.getRemult()).toBe(undefined);
+                expressBridge_1.RemultAsyncLocalStorage.enable();
+                try {
+                    remult_proxy_1.remult.isAllowed(false);
+                    gotException = false;
+                }
+                catch (_c) { }
+                expect(gotException).toBe(true);
+                promises = [];
+                expressBridge_1.RemultAsyncLocalStorage.instance.run(new context_1.Remult(), function () {
+                    remult_proxy_1.remult.user = { id: 'noam' };
+                    promises.push(new Promise(function (res) {
+                        setTimeout(function () {
+                            expect(remult_proxy_1.remult.user.id).toBe('noam');
+                            res({});
+                        }, 10);
+                    }));
+                    expressBridge_1.RemultAsyncLocalStorage.instance.run(new context_1.Remult(), function () {
+                        remult_proxy_1.remult.user = { id: 'yoni' };
+                        promises.push(new Promise(function (res) {
+                            setTimeout(function () {
+                                expect(remult_proxy_1.remult.user.id).toBe('yoni');
+                                res({});
+                            }, 10);
+                        }));
+                    });
+                    promises.push(new Promise(function (res) {
+                        setTimeout(function () {
+                            expect(remult_proxy_1.remult.user.id).toBe('noam');
+                            res({});
+                        }, 10);
+                    }));
+                });
+                return [4 /*yield*/, Promise.all(promises)];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); });

package/src/backend-tests/test-http-server.backend-spec.d.ts

@@ -0,0 +1,6 @@
+export declare class Task {
+    id: string;
+    title: string;
+    completed: boolean;
+    static testForbidden(): void;
+}

package/src/backend-tests/test-http-server.backend-spec.js

@@ -0,0 +1,342 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Task = void 0;
+var tslib_1 = require("tslib");
+var axios_1 = require("axios");
+var remult_fresh_1 = require("../../remult-fresh");
+var in_memory_database_1 = require("../data-providers/in-memory-database");
+var remult_proxy_1 = require("../remult-proxy");
+var remult3_1 = require("../remult3");
+var server_action_1 = require("../server-action");
+var remult_3_entities_1 = require("../tests/remult-3-entities");
+remult_proxy_1.remult.apiClient.url = 'http://localhost:3003/api';
+var path = remult_proxy_1.remult.apiClient.url + '/tasks';
+var environments = [
+// ["next", 3000],
+// ["nest", 3001],
+//  ["koa", 3002],
+//  ["fastify", 3003],
+//  ["express", 3004],
+//  ["generic server", 3005],
+// ["optine", 3006],
+// ["fresh", 8000]
+];
+function test(name, test) {
+    var e_1, _a;
+    var _this = this;
+    var _loop_1 = function (env, port) {
+        var theTest = function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        remult_proxy_1.remult.apiClient.url = "http://localhost:" + port + "/api";
+                        path = remult_proxy_1.remult.apiClient.url + '/tasks';
+                        return [4 /*yield*/, test()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+        var testName = env + (" " + port + ": " + name);
+        fit(testName, theTest);
+    };
+    try {
+        for (var environments_1 = tslib_1.__values(environments), environments_1_1 = environments_1.next(); !environments_1_1.done; environments_1_1 = environments_1.next()) {
+            var _b = tslib_1.__read(environments_1_1.value, 2), env = _b[0], port = _b[1];
+            _loop_1(env, port);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (environments_1_1 && !environments_1_1.done && (_a = environments_1.return)) _a.call(environments_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+}
+test("works", function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+    var repo, tasks, _a;
+    return tslib_1.__generator(this, function (_b) {
+        switch (_b.label) {
+            case 0: return [4 /*yield*/, create3Tasks()];
+            case 1:
+                repo = _b.sent();
+                return [4 /*yield*/, repo.find({ where: { completed: true } })];
+            case 2:
+                tasks = _b.sent();
+                expect(tasks.length).toBe(1);
+                return [4 /*yield*/, repo.save(tslib_1.__assign(tslib_1.__assign({}, tasks[0]), { completed: false }))];
+            case 3:
+                _b.sent();
+                _a = expect;
+                return [4 /*yield*/, repo.count({ completed: true })];
+            case 4:
+                _a.apply(void 0, [_b.sent()]).toBe(0);
+                return [2 /*return*/];
+        }
+    });
+}); });
+test("test multiple items", function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+    var repo, _a;
+    return tslib_1.__generator(this, function (_b) {
+        switch (_b.label) {
+            case 0: return [4 /*yield*/, create3Tasks()];
+            case 1:
+                repo = _b.sent();
+                _a = expect;
+                return [4 /*yield*/, repo.count({
+                        title: { "!=": ["a", "c"] }
+                    })];
+            case 2:
+                _a.apply(void 0, [_b.sent()]).toBe(1);
+                return [2 /*return*/];
+        }
+    });
+}); });
+test("validation", function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+    var r, err, error_1;
+    return tslib_1.__generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, create3Tasks()];
+            case 1:
+                r = _a.sent();
+                err = undefined;
+                _a.label = 2;
+            case 2:
+                _a.trys.push([2, 4, , 5]);
+                return [4 /*yield*/, r.insert({ "title": "" })];
+            case 3:
+                _a.sent();
+                return [3 /*break*/, 5];
+            case 4:
+                error_1 = _a.sent();
+                err = error_1;
+                return [3 /*break*/, 5];
+            case 5:
+                expect(err).toEqual({
+                    message: "Title: Should not be empty",
+                    httpStatusCode: 400,
+                    modelState: {
+                        title: "Should not be empty"
+                    }
+                });
+                return [2 /*return*/];
+        }
+    });
+}); });
+test("forbidden", function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+    var err, error_2;
+    return tslib_1.__generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                err = undefined;
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, 3, , 4]);
+                return [4 /*yield*/, Task.testForbidden()];
+            case 2:
+                _a.sent();
+                return [3 /*break*/, 4];
+            case 3:
+                error_2 = _a.sent();
+                err = error_2;
+                return [3 /*break*/, 4];
+            case 4:
+                expect(err.httpStatusCode).toEqual(403);
+                return [2 /*return*/];
+        }
+    });
+}); });
+test("test http 404", function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+    var repo, task, result, error, err_1;
+    return tslib_1.__generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                repo = create3Tasks();
+                return [4 /*yield*/, repo];
+            case 1: return [4 /*yield*/, (_a.sent()).findFirst()];
+            case 2:
+                task = _a.sent();
+                return [4 /*yield*/, axios_1.default.get(path + "/" + task.id)];
+            case 3:
+                result = _a.sent();
+                expect(result.data.id).toBe(task.id);
+                expect(result.status).toBe(200);
+                error = undefined;
+                _a.label = 4;
+            case 4:
+                _a.trys.push([4, 6, , 7]);
+                return [4 /*yield*/, axios_1.default.get(path + "/123")];
+            case 5:
+                result = _a.sent();
+                return [3 /*break*/, 7];
+            case 6:
+                err_1 = _a.sent();
+                error = err_1;
+                return [3 /*break*/, 7];
+            case 7:
+                expect(error.response.status).toBe(404);
+                return [2 /*return*/];
+        }
+    });
+}); });
+test("test http 201", function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+    var result;
+    return tslib_1.__generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, axios_1.default.post(path, { title: "z", id: "" })];
+            case 1:
+                result = _a.sent();
+                expect(result.data.title).toBe("z");
+                expect(result.status).toBe(201);
+                return [4 /*yield*/, axios_1.default.delete(path + "/" + result.data.id)];
+            case 2:
+                result = _a.sent();
+                expect(result.status).toBe(204);
+                return [2 /*return*/];
+        }
+    });
+}); });
+test("test regular api call", function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+    var result;
+    return tslib_1.__generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, create3Tasks()];
+            case 1:
+                _a.sent();
+                return [4 /*yield*/, axios_1.default.get(remult_proxy_1.remult.apiClient.url + "/test")];
+            case 2:
+                result = _a.sent();
+                expect(result.data.result).toBe(3);
+                return [2 /*return*/];
+        }
+    });
+}); });
+var FreshResponseTest = /** @class */ (function () {
+    function FreshResponseTest(body, init) {
+        this.body = body;
+        this.init = init;
+    }
+    FreshResponseTest.json = function (data, init) {
+        return new this(data, init);
+    };
+    return FreshResponseTest;
+}());
+it("test fresh", function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+    var api, r;
+    return tslib_1.__generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                api = remult_fresh_1.remultFresh({
+                    entities: [remult_3_entities_1.Categories],
+                    dataProvider: new in_memory_database_1.InMemoryDataProvider(),
+                    rootPath: '/api'
+                }, FreshResponseTest);
+                return [4 /*yield*/, api.handle({
+                        url: '/api/Categories',
+                        json: function () {
+                            return undefined;
+                        },
+                        method: "get"
+                    }, {
+                        next: function () {
+                            return undefined;
+                        },
+                    })];
+            case 1:
+                r = _a.sent();
+                expect(r.body).toEqual([]);
+                return [2 /*return*/];
+        }
+    });
+}); });
+var Task = /** @class */ (function () {
+    function Task() {
+        this.title = '';
+        this.completed = false;
+    }
+    Task.testForbidden = function () {
+    };
+    tslib_1.__decorate([
+        remult3_1.Fields.uuid(),
+        tslib_1.__metadata("design:type", String)
+    ], Task.prototype, "id", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.string({
+        //  validate: Validators.required should only be on backend
+        }),
+        tslib_1.__metadata("design:type", Object)
+    ], Task.prototype, "title", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.boolean(),
+        tslib_1.__metadata("design:type", Object)
+    ], Task.prototype, "completed", void 0);
+    tslib_1.__decorate([
+        server_action_1.BackendMethod({ allowed: false }),
+        tslib_1.__metadata("design:type", Function),
+        tslib_1.__metadata("design:paramtypes", []),
+        tslib_1.__metadata("design:returntype", void 0)
+    ], Task, "testForbidden", null);
+    Task = tslib_1.__decorate([
+        remult3_1.Entity("tasks", {
+            allowApiCrud: true
+        })
+    ], Task);
+    return Task;
+}());
+exports.Task = Task;
+function create3Tasks() {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var taskRepo, _a, _b, task, e_2_1, _c, _d;
+        var e_2, _e;
+        return tslib_1.__generator(this, function (_f) {
+            switch (_f.label) {
+                case 0:
+                    remult_proxy_1.remult.apiClient.httpClient = axios_1.default;
+                    taskRepo = remult_proxy_1.remult.repo(Task);
+                    _f.label = 1;
+                case 1:
+                    _f.trys.push([1, 7, 8, 9]);
+                    return [4 /*yield*/, taskRepo.find()];
+                case 2:
+                    _a = tslib_1.__values.apply(void 0, [_f.sent()]), _b = _a.next();
+                    _f.label = 3;
+                case 3:
+                    if (!!_b.done) return [3 /*break*/, 6];
+                    task = _b.value;
+                    return [4 /*yield*/, taskRepo.delete(task)];
+                case 4:
+                    _f.sent();
+                    _f.label = 5;
+                case 5:
+                    _b = _a.next();
+                    return [3 /*break*/, 3];
+                case 6: return [3 /*break*/, 9];
+                case 7:
+                    e_2_1 = _f.sent();
+                    e_2 = { error: e_2_1 };
+                    return [3 /*break*/, 9];
+                case 8:
+                    try {
+                        if (_b && !_b.done && (_e = _a.return)) _e.call(_a);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                    return [7 /*endfinally*/];
+                case 9:
+                    _c = expect;
+                    return [4 /*yield*/, taskRepo.count()];
+                case 10:
+                    _c.apply(void 0, [_f.sent()]).toBe(0);
+                    return [4 /*yield*/, taskRepo.insert([{ title: "a" }, { title: "b", completed: true }, { title: "c" }])];
+                case 11:
+                    _f.sent();
+                    _d = expect;
+                    return [4 /*yield*/, taskRepo.count()];
+                case 12:
+                    _d.apply(void 0, [_f.sent()]).toBe(3);
+                    return [2 /*return*/, taskRepo];
+            }
+        });
+    });
+}

package/src/id-entity.d.ts

@@ -0,0 +1,4 @@
+import { EntityBase } from './remult3';
+export declare class IdEntity extends EntityBase {
+    id: string;
+}

package/src/id-entity.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdEntity = void 0;
+var tslib_1 = require("tslib");
+var remult3_1 = require("./remult3");
+var IdEntity = /** @class */ (function (_super) {
+    tslib_1.__extends(IdEntity, _super);
+    function IdEntity() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    tslib_1.__decorate([
+        remult3_1.Fields.uuid(),
+        tslib_1.__metadata("design:type", String)
+    ], IdEntity.prototype, "id", void 0);
+    return IdEntity;
+}(remult3_1.EntityBase));
+exports.IdEntity = IdEntity;