remult 0.22.0 → 0.22.2

package/esm/remult-mongo.js

@@ -20,19 +20,24 @@ export class MongoDataProvider {
         return new MongoEntityDataProvider(this.db, entity, this.session);
     }
     async transaction(action) {
-        let session = await this.client.startSession();
-        session.startTransaction();
-        const db = this.client.db(this.db.databaseName);
-        try {
-            await action(new MongoDataProvider(db, undefined, { session }));
-            await session.commitTransaction();
+        if (this.disableTransactions) {
+            await action(this);
         }
-        catch (err) {
-            await session.abortTransaction();
-            throw err;
-        }
-        finally {
-            await session.endSession();
+        else {
+            let session = await this.client.startSession();
+            session.startTransaction();
+            const db = this.client.db(this.db.databaseName);
+            try {
+                await action(new MongoDataProvider(db, undefined, { session }));
+                await session.commitTransaction();
+            }
+            catch (err) {
+                await session.abortTransaction();
+                throw err;
+            }
+            finally {
+                await session.endSession();
+            }
         }
     }
     static async filterToRaw(entity, condition) {
@@ -54,7 +59,7 @@ class MongoEntityDataProvider {
         this.entity = entity;
         this.session = session;
     }
-    translateFromJson(row, nameProvider) {
+    translateFromDb(row, nameProvider) {
         let result = {};
         for (const col of this.entity.fields) {
             let val = row[nameProvider.$dbNameOf(col)];
@@ -64,7 +69,7 @@ class MongoEntityDataProvider {
         }
         return result;
     }
-    translateToJson(row, nameProvider) {
+    translateToDb(row, nameProvider) {
         let result = {};
         for (const col of this.entity.fields) {
             let val = col.valueConverter.toDb(row[col.key]);
@@ -104,7 +109,7 @@ class MongoEntityDataProvider {
         }
         return await Promise.all(await collection
             .find(where, op)
-            .map((x) => this.translateFromJson(x, e))
+            .map((x) => this.translateFromDb(x, e))
             .toArray());
     }
     async update(id, data) {
@@ -124,7 +129,7 @@ class MongoEntityDataProvider {
         for (const f of this.entity.fields) {
             if (!f.dbReadOnly && !f.isServerExpression) {
                 if (keys.includes(f.key)) {
-                    newR[f.key] = f.valueConverter.toJson(data[f.key]);
+                    newR[f.key] = f.valueConverter.toDb(data[f.key]);
                 }
             }
         }
@@ -143,10 +148,10 @@ class MongoEntityDataProvider {
     }
     async insert(data) {
         let { collection, e } = await this.collection();
-        let r = await collection.insertOne(await this.translateToJson(data, e), {
+        let r = await collection.insertOne(await this.translateToDb(data, e), {
             session: this.session,
         });
-        return await this.translateFromJson(await collection.findOne({ _id: r.insertedId }, { session: this.session }), e);
+        return await this.translateFromDb(await collection.findOne({ _id: r.insertedId }, { session: this.session }), e);
     }
     async collection() {
         const e = await dbNamesOf(this.entity);

package/esm/src/backend-tests/backend-database-test-setup.backend-spec.d.ts

@@ -2,5 +2,6 @@ import { dbTestWhatSignature } from '../shared-tests/db-tests-setup';
 export declare const testKnexPGSqlImpl: (key: string, what: dbTestWhatSignature, focus?: boolean) => void;
 export declare const mySqlTest: import("../shared-tests/db-tests-setup").dbTestMethodSignature;
 export declare function testPostgresImplementation(key: string, what: dbTestWhatSignature, focus?: boolean): void;
-export declare function testMongo(key: string, what: dbTestWhatSignature, focus?: boolean): void;
+export declare const testMongo: (key: string, what: dbTestWhatSignature, focus?: boolean) => void;
+export declare const testMongoNoTrans: (key: string, what: dbTestWhatSignature, focus?: boolean) => void;
 import '../shared-tests';

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

@@ -4,7 +4,7 @@ import * as Knex from 'knex';
 import { MongoClient } from 'mongodb';
 import { config } from 'dotenv';
 import { createPostgresConnection, PostgresSchemaBuilder, } from '../../postgres';
-import { addDatabaseToTest, itWithFocus, testAll, TestDbs, } from '../shared-tests/db-tests-setup';
+import { addDatabaseToTest, itWithFocus, TestDbs, } from '../shared-tests/db-tests-setup';
 import { describeClass } from '../remult3/DecoratorReplacer';
 import { Entity, Fields } from '../remult3';
 KnexSchemaBuilder.logToConsole = false;
@@ -84,43 +84,72 @@ export function testPostgresImplementation(key, what, focus = false) {
 addDatabaseToTest(testPostgresImplementation);
 import { Categories } from '../tests/remult-3-entities';
 import { MongoDataProvider } from '../../remult-mongo';
-testAll('transactions', async ({ db, createEntity }) => {
-    let x = await createEntity(Categories);
-    await db.transaction(async (db) => {
-        let remult = new Remult(db);
-        expect(await remult.repo(Categories).count()).toBe(0);
+export const testMongo = (() => {
+    const mongoConnectionString = process.env['MONGO_TEST_URL']; //"mongodb://localhost:27017/local"
+    let client = new MongoClient(mongoConnectionString);
+    let done;
+    let mongoDbPromise = client.connect().then((c) => {
+        done = c;
+        return c.db('test');
     });
-});
-const mongoConnectionString = process.env['MONGO_TEST_URL']; //"mongodb://localhost:27017/local"
-let client = new MongoClient(mongoConnectionString);
-let done;
-let mongoDbPromise = client.connect().then((c) => {
-    done = c;
-    return c.db('test');
-});
-afterAll(async () => {
-    if (done)
-        done.close();
-});
-export function testMongo(key, what, focus = false) {
-    itWithFocus(key + ' - mongo', async () => {
-        let mongoDb = await mongoDbPromise;
-        let db = new MongoDataProvider(mongoDb, client);
-        let remult = new Remult(db);
-        await what({
-            db,
-            remult,
-            createEntity: async (entity) => {
-                let repo = remult.repo(entity);
-                await mongoDb
-                    .collection(await repo.metadata.getDbName())
-                    .deleteMany({});
-                return repo;
-            },
-        });
-    }, focus);
-}
+    afterAll(async () => {
+        if (done)
+            done.close();
+    });
+    return function testMongo(key, what, focus = false) {
+        itWithFocus(key + ' - mongo', async () => {
+            let mongoDb = await mongoDbPromise;
+            let db = new MongoDataProvider(mongoDb, client);
+            let remult = new Remult(db);
+            await what({
+                db,
+                remult,
+                createEntity: async (entity) => {
+                    let repo = remult.repo(entity);
+                    await mongoDb
+                        .collection(await repo.metadata.getDbName())
+                        .deleteMany({});
+                    return repo;
+                },
+            });
+        }, focus);
+    };
+})();
+export const testMongoNoTrans = (() => {
+    const mongoConnectionString = 'mongodb://localhost:27017/local';
+    let client = new MongoClient(mongoConnectionString);
+    let done;
+    let mongoDbPromise = client.connect().then((c) => {
+        done = c;
+        return c.db('test');
+    });
+    afterAll(async () => {
+        if (done)
+            done.close();
+    });
+    return function testMongo(key, what, focus = false) {
+        itWithFocus(key + ' - ' + TestDbs.mongoNoTrans, async () => {
+            let mongoDb = await mongoDbPromise;
+            let db = new MongoDataProvider(mongoDb, client, {
+                disableTransactions: true,
+            });
+            let remult = new Remult(db);
+            await what({
+                db,
+                remult,
+                createEntity: async (entity) => {
+                    let repo = remult.repo(entity);
+                    await mongoDb
+                        .collection(await repo.metadata.getDbName())
+                        .deleteMany({});
+                    return repo;
+                },
+            });
+        }, focus);
+    };
+})();
 addDatabaseToTest(testMongo, TestDbs.mongo);
+addDatabaseToTest(testMongoNoTrans, TestDbs.mongoNoTrans);
 it('test mongo without transaction', async () => {
     const client = new MongoClient('mongodb://localhost:27017/local');
     await client.connect();
@@ -145,12 +174,49 @@ it('test mongo without transaction', async () => {
     }
     await repo.insert({ id: 1, title: 'a' });
     try {
-        await db.transaction(async () => {
-            await repo.insert({ id: 2, title: 'b' });
-            throw new Error();
+        await db.transaction(async (dbWithTrans) => {
+            await new Remult(dbWithTrans).repo(entity).insert({ id: 2, title: 'b' });
+            throw 'Error';
         });
     }
-    catch { }
+    catch (err) {
+        expect(err).toBe('Error');
+    }
     expect(await repo.count()).toBe(2);
 });
+testMongoNoTrans('transactions mongo no trans', async ({ db, createEntity }) => {
+    let x = await createEntity(Categories);
+    try {
+        await db.transaction(async (db) => {
+            let remult = new Remult(db);
+            await remult.repo(Categories).insert({ categoryName: 'testing' });
+            expect(await remult.repo(Categories).count()).toBe(1);
+            throw 'Fail';
+        });
+    }
+    catch (err) {
+        expect(err).toBe('Fail');
+    }
+    expect(await x.count()).toBe(1);
+}, false);
+testMongoNoTrans('test Dates', async ({ createEntity }) => {
+    const c = class {
+    };
+    describeClass(c, Entity('test_dates_on_mongo'), {
+        id: Fields.integer(),
+        date: Fields.date(),
+    });
+    const r = await createEntity(c);
+    let x = await r.insert({ id: 1, date: new Date(1976, 5, 16) });
+    const client = new MongoClient('mongodb://localhost:27017/local');
+    await client.connect();
+    const mongoDb = client.db('test');
+    expect((await mongoDb.collection(await r.metadata.getDbName()).findOne())
+        .date instanceof Date).toBe(true);
+    x.date = new Date(1978, 2, 15);
+    await r.save(x);
+    expect((await mongoDb.collection(await r.metadata.getDbName()).findOne())
+        .date instanceof Date).toBe(true);
+    //let z = await r.save({ ...x, date: new Date(1978, 2, 15) })
+}, false);
 import '../shared-tests';

package/esm/src/shared-tests/db-tests-setup.d.ts

@@ -12,7 +12,9 @@ export declare function addDatabaseToTest(tester: dbTestMethodSignature, key?: s
 export declare function testInMemory(key: string, what: dbTestWhatSignature, focus?: boolean): void;
 export declare const TestDbs: {
     restDataProvider: string;
+    webSql: string;
     mongo: string;
+    mongoNoTrans: string;
     inMemory: string;
 };
 export declare type dbTestWhatSignature = (db: {

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

@@ -40,7 +40,9 @@ export function testInMemory(key, what, focus = false) {
 }
 export const TestDbs = {
     restDataProvider: 'restDataProvider',
+    webSql: 'webSql',
     mongo: 'mongo',
+    mongoNoTrans: 'mongoNoTrans',
     inMemory: 'in memory',
 };
 addDatabaseToTest(testInMemory, TestDbs.inMemory);

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

@@ -4,7 +4,7 @@ import { Fields, Entity, EntityBase, Field, IdEntity, } from '../remult3';
 import { c } from '../tests/c';
 import { Done } from '../tests/Done';
 import { h } from '../tests/h';
-import { Categories as newCategories } from '../tests/remult-3-entities';
+import { Categories, Categories as newCategories, } from '../tests/remult-3-entities';
 import { tasks } from '../tests/tasks';
 import { TestDataApiResponse } from '../tests/TestDataApiResponse';
 import { testAll, testAllDbs, TestDbs } from './db-tests-setup';
@@ -829,10 +829,50 @@ testAll('test transaction rollback', async ({ db, createEntity }) => {
         });
         fail = false;
     }
-    catch { }
+    catch (err) {
+        expect(err).toBe('error');
+    }
     expect(await r.count()).toBe(1);
     expect(fail).toBe(true);
-}, false, { exclude: [TestDbs.inMemory] });
+}, false, {
+    exclude: [
+        TestDbs.inMemory,
+        TestDbs.mongoNoTrans,
+        TestDbs.restDataProvider,
+        TestDbs.webSql,
+    ],
+});
+testAll('transactions', async ({ db, createEntity }) => {
+    let x = await createEntity(Categories);
+    await db.transaction(async (db) => {
+        let remult = new Remult(db);
+        expect(await remult.repo(Categories).count()).toBe(0);
+    });
+}, false, {
+    exclude: [TestDbs.mongoNoTrans, TestDbs.restDataProvider, TestDbs.webSql],
+});
+testAll('transactions 1', async ({ db, createEntity }) => {
+    let x = await createEntity(Categories);
+    try {
+        await db.transaction(async (db) => {
+            let remult = new Remult(db);
+            await remult.repo(Categories).insert({ categoryName: 'testing' });
+            expect(await remult.repo(Categories).count()).toBe(1);
+            throw 'Fail';
+        });
+    }
+    catch (err) {
+        expect(err).toBe('Fail');
+    }
+    expect(await x.count()).toBe(0);
+}, false, {
+    exclude: [
+        TestDbs.inMemory,
+        TestDbs.mongoNoTrans,
+        TestDbs.restDataProvider,
+        TestDbs.webSql,
+    ],
+});
 testAll('test date', async ({ createEntity }) => {
     const e = class {
         constructor() {
@@ -879,7 +919,7 @@ testAll('test contains with names with casing', async ({ createEntity }) => {
     let item = await r.findFirst({ firstName: { $contains: 'oa' } });
     expect(item.firstName).toBe('noam');
 }, false, {
-    exclude: [TestDbs.mongo],
+    exclude: [TestDbs.mongo, TestDbs.mongoNoTrans],
 });
 testAll('test live query storage', async (x) => {
     await x.createEntity(LiveQueryStorageEntity);
@@ -1005,7 +1045,7 @@ testAll('test json structure 3', async ({ createEntity }) => {
     expect(item.items).toEqual(['a', 'b']);
     expect(await r.count({ items: { $contains: 'b' } })).toBe(1);
 }, false, {
-    exclude: [TestDbs.mongo],
+    exclude: [TestDbs.mongo, TestDbs.mongoNoTrans],
 });
 testAll('test relation to number id', async ({ createEntity }) => {
     const category = class {
@@ -1041,4 +1081,4 @@ testAll('test relation to number id', async ({ createEntity }) => {
     expect(await taskRepo.count({ category: cat[0] })).toBe(2);
     expect(await taskRepo.count({ category: cat[1] })).toBe(1);
     expect(await taskRepo.count({ category: { $id: cat[0].id } })).toBe(2);
-}, false, { exclude: [TestDbs.mongo] });
+}, false, { exclude: [TestDbs.mongo, TestDbs.mongoNoTrans] });

package/esm/src/tests/frontend-database-tests-setup.spec.js

@@ -23,7 +23,7 @@ export function testWebSqlImpl(key, what, focus = false) {
         await what({ db: sql, remult, createEntity: async (x) => remult.repo(x) });
     }, focus);
 }
-addDatabaseToTest(testWebSqlImpl);
+addDatabaseToTest(testWebSqlImpl, TestDbs.webSql);
 export function testRest(key, what, focus = false) {
     itWithFocus(key + ' - Rest Provider', async () => {
         let r = new Remult();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.22.0",
+    "version": "0.22.2",
     "description": "A CRUD framework for full-stack TypeScript",
     "types": "index.d.ts",
     "module": "esm/index.js",

package/remult-mongo.js

@@ -28,32 +28,38 @@ var MongoDataProvider = /** @class */ (function () {
             var session, db, err_1;
             return tslib_1.__generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.client.startSession()];
+                    case 0:
+                        if (!this.disableTransactions) return [3 /*break*/, 2];
+                        return [4 /*yield*/, action(this)];
                     case 1:
+                        _a.sent();
+                        return [3 /*break*/, 11];
+                    case 2: return [4 /*yield*/, this.client.startSession()];
+                    case 3:
                         session = _a.sent();
                         session.startTransaction();
                         db = this.client.db(this.db.databaseName);
-                        _a.label = 2;
-                    case 2:
-                        _a.trys.push([2, 5, 7, 9]);
+                        _a.label = 4;
+                    case 4:
+                        _a.trys.push([4, 7, 9, 11]);
                         return [4 /*yield*/, action(new MongoDataProvider(db, undefined, { session: session }))];
-                    case 3:
+                    case 5:
                         _a.sent();
                         return [4 /*yield*/, session.commitTransaction()];
-                    case 4:
+                    case 6:
                         _a.sent();
-                        return [3 /*break*/, 9];
-                    case 5:
+                        return [3 /*break*/, 11];
+                    case 7:
                         err_1 = _a.sent();
                         return [4 /*yield*/, session.abortTransaction()];
-                    case 6:
+                    case 8:
                         _a.sent();
                         throw err_1;
-                    case 7: return [4 /*yield*/, session.endSession()];
-                    case 8:
+                    case 9: return [4 /*yield*/, session.endSession()];
+                    case 10:
                         _a.sent();
                         return [7 /*endfinally*/];
-                    case 9: return [2 /*return*/];
+                    case 11: return [2 /*return*/];
                 }
             });
         });
@@ -95,7 +101,7 @@ var MongoEntityDataProvider = /** @class */ (function () {
         this.entity = entity;
         this.session = session;
     }
-    MongoEntityDataProvider.prototype.translateFromJson = function (row, nameProvider) {
+    MongoEntityDataProvider.prototype.translateFromDb = function (row, nameProvider) {
         var e_1, _a;
         var result = {};
         try {
@@ -116,7 +122,7 @@ var MongoEntityDataProvider = /** @class */ (function () {
         }
         return result;
     };
-    MongoEntityDataProvider.prototype.translateToJson = function (row, nameProvider) {
+    MongoEntityDataProvider.prototype.translateToDb = function (row, nameProvider) {
         var e_2, _a;
         var result = {};
         try {
@@ -200,7 +206,7 @@ var MongoEntityDataProvider = /** @class */ (function () {
                         _e = (_d = Promise).all;
                         return [4 /*yield*/, collection
                                 .find(where, op)
-                                .map(function (x) { return _this.translateFromJson(x, e); })
+                                .map(function (x) { return _this.translateFromDb(x, e); })
                                 .toArray()];
                     case 3: return [4 /*yield*/, _e.apply(_d, [_g.sent()])];
                     case 4: return [2 /*return*/, _g.sent()];
@@ -244,7 +250,7 @@ var MongoEntityDataProvider = /** @class */ (function () {
                                 f_1 = _e.value;
                                 if (!f_1.dbReadOnly && !f_1.isServerExpression) {
                                     if (keys.includes(f_1.key)) {
-                                        newR[f_1.key] = f_1.valueConverter.toJson(data[f_1.key]);
+                                        newR[f_1.key] = f_1.valueConverter.toDb(data[f_1.key]);
                                     }
                                 }
                             }
@@ -299,13 +305,13 @@ var MongoEntityDataProvider = /** @class */ (function () {
                     case 1:
                         _a = _e.sent(), collection = _a.collection, e = _a.e;
                         _c = (_b = collection).insertOne;
-                        return [4 /*yield*/, this.translateToJson(data, e)];
+                        return [4 /*yield*/, this.translateToDb(data, e)];
                     case 2: return [4 /*yield*/, _c.apply(_b, [_e.sent(), {
                                 session: this.session,
                             }])];
                     case 3:
                         r = _e.sent();
-                        _d = this.translateFromJson;
+                        _d = this.translateFromDb;
                         return [4 /*yield*/, collection.findOne({ _id: r.insertedId }, { session: this.session })];
                     case 4: return [4 /*yield*/, _d.apply(this, [_e.sent(), e])];
                     case 5: return [2 /*return*/, _e.sent()];

package/src/backend-tests/backend-database-test-setup.backend-spec.d.ts

@@ -2,5 +2,6 @@ import { dbTestWhatSignature } from '../shared-tests/db-tests-setup';
 export declare const testKnexPGSqlImpl: (key: string, what: dbTestWhatSignature, focus?: boolean) => void;
 export declare const mySqlTest: import("../shared-tests/db-tests-setup").dbTestMethodSignature;
 export declare function testPostgresImplementation(key: string, what: dbTestWhatSignature, focus?: boolean): void;
-export declare function testMongo(key: string, what: dbTestWhatSignature, focus?: boolean): void;
+export declare const testMongo: (key: string, what: dbTestWhatSignature, focus?: boolean) => void;
+export declare const testMongoNoTrans: (key: string, what: dbTestWhatSignature, focus?: boolean) => void;
 import '../shared-tests';

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.testMongo = exports.testPostgresImplementation = exports.mySqlTest = exports.testKnexPGSqlImpl = void 0;
+exports.testMongoNoTrans = exports.testMongo = exports.testPostgresImplementation = exports.mySqlTest = exports.testKnexPGSqlImpl = void 0;
 var tslib_1 = require("tslib");
 var context_1 = require("../context");
 var remult_knex_1 = require("../../remult-knex");
@@ -139,103 +139,134 @@ exports.testPostgresImplementation = testPostgresImplementation;
 db_tests_setup_1.addDatabaseToTest(testPostgresImplementation);
 var remult_3_entities_1 = require("../tests/remult-3-entities");
 var remult_mongo_1 = require("../../remult-mongo");
-db_tests_setup_1.testAll('transactions', function (_a) {
-    var db = _a.db, createEntity = _a.createEntity;
-    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
-        var x;
-        return tslib_1.__generator(this, function (_b) {
-            switch (_b.label) {
-                case 0: return [4 /*yield*/, createEntity(remult_3_entities_1.Categories)];
-                case 1:
-                    x = _b.sent();
-                    return [4 /*yield*/, db.transaction(function (db) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
-                            var remult, _a;
-                            return tslib_1.__generator(this, function (_b) {
-                                switch (_b.label) {
-                                    case 0:
-                                        remult = new context_1.Remult(db);
-                                        _a = expect;
-                                        return [4 /*yield*/, remult.repo(remult_3_entities_1.Categories).count()];
-                                    case 1:
-                                        _a.apply(void 0, [_b.sent()]).toBe(0);
-                                        return [2 /*return*/];
-                                }
-                            });
-                        }); })];
-                case 2:
-                    _b.sent();
-                    return [2 /*return*/];
-            }
-        });
-    });
-});
-var mongoConnectionString = process.env['MONGO_TEST_URL']; //"mongodb://localhost:27017/local"
-var client = new mongodb_1.MongoClient(mongoConnectionString);
-var done;
-var mongoDbPromise = client.connect().then(function (c) {
-    done = c;
-    return c.db('test');
-});
-afterAll(function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
-    return tslib_1.__generator(this, function (_a) {
-        if (done)
-            done.close();
-        return [2 /*return*/];
+exports.testMongo = (function () {
+    var mongoConnectionString = process.env['MONGO_TEST_URL']; //"mongodb://localhost:27017/local"
+    var client = new mongodb_1.MongoClient(mongoConnectionString);
+    var done;
+    var mongoDbPromise = client.connect().then(function (c) {
+        done = c;
+        return c.db('test');
     });
-}); });
-function testMongo(key, what, focus) {
-    var _this = this;
-    if (focus === void 0) { focus = false; }
-    db_tests_setup_1.itWithFocus(key + ' - mongo', function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-        var mongoDb, db, remult;
+    afterAll(function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        return tslib_1.__generator(this, function (_a) {
+            if (done)
+                done.close();
+            return [2 /*return*/];
+        });
+    }); });
+    return function testMongo(key, what, focus) {
         var _this = this;
+        if (focus === void 0) { focus = false; }
+        db_tests_setup_1.itWithFocus(key + ' - mongo', function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var mongoDb, db, remult;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, mongoDbPromise];
+                    case 1:
+                        mongoDb = _a.sent();
+                        db = new remult_mongo_1.MongoDataProvider(mongoDb, client);
+                        remult = new context_1.Remult(db);
+                        return [4 /*yield*/, what({
+                                db: db,
+                                remult: remult,
+                                createEntity: function (entity) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                    var repo, _a, _b;
+                                    return tslib_1.__generator(this, function (_c) {
+                                        switch (_c.label) {
+                                            case 0:
+                                                repo = remult.repo(entity);
+                                                _b = (_a = mongoDb)
+                                                    .collection;
+                                                return [4 /*yield*/, repo.metadata.getDbName()];
+                                            case 1: return [4 /*yield*/, _b.apply(_a, [_c.sent()])
+                                                    .deleteMany({})];
+                                            case 2:
+                                                _c.sent();
+                                                return [2 /*return*/, repo];
+                                        }
+                                    });
+                                }); },
+                            })];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); }, focus);
+    };
+})();
+exports.testMongoNoTrans = (function () {
+    var mongoConnectionString = 'mongodb://localhost:27017/local';
+    var client = new mongodb_1.MongoClient(mongoConnectionString);
+    var done;
+    var mongoDbPromise = client.connect().then(function (c) {
+        done = c;
+        return c.db('test');
+    });
+    afterAll(function () { 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*/, mongoDbPromise];
-                case 1:
-                    mongoDb = _a.sent();
-                    db = new remult_mongo_1.MongoDataProvider(mongoDb, client);
-                    remult = new context_1.Remult(db);
-                    return [4 /*yield*/, what({
-                            db: db,
-                            remult: remult,
-                            createEntity: function (entity) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                                var repo, _a, _b;
-                                return tslib_1.__generator(this, function (_c) {
-                                    switch (_c.label) {
-                                        case 0:
-                                            repo = remult.repo(entity);
-                                            _b = (_a = mongoDb)
-                                                .collection;
-                                            return [4 /*yield*/, repo.metadata.getDbName()];
-                                        case 1: return [4 /*yield*/, _b.apply(_a, [_c.sent()])
-                                                .deleteMany({})];
-                                        case 2:
-                                            _c.sent();
-                                            return [2 /*return*/, repo];
-                                    }
-                                });
-                            }); },
-                        })];
-                case 2:
-                    _a.sent();
-                    return [2 /*return*/];
-            }
+            if (done)
+                done.close();
+            return [2 /*return*/];
         });
-    }); }, focus);
-}
-exports.testMongo = testMongo;
-db_tests_setup_1.addDatabaseToTest(testMongo, db_tests_setup_1.TestDbs.mongo);
+    }); });
+    return function testMongo(key, what, focus) {
+        var _this = this;
+        if (focus === void 0) { focus = false; }
+        db_tests_setup_1.itWithFocus(key + ' - ' + db_tests_setup_1.TestDbs.mongoNoTrans, function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var mongoDb, db, remult;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, mongoDbPromise];
+                    case 1:
+                        mongoDb = _a.sent();
+                        db = new remult_mongo_1.MongoDataProvider(mongoDb, client, {
+                            disableTransactions: true,
+                        });
+                        remult = new context_1.Remult(db);
+                        return [4 /*yield*/, what({
+                                db: db,
+                                remult: remult,
+                                createEntity: function (entity) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                    var repo, _a, _b;
+                                    return tslib_1.__generator(this, function (_c) {
+                                        switch (_c.label) {
+                                            case 0:
+                                                repo = remult.repo(entity);
+                                                _b = (_a = mongoDb)
+                                                    .collection;
+                                                return [4 /*yield*/, repo.metadata.getDbName()];
+                                            case 1: return [4 /*yield*/, _b.apply(_a, [_c.sent()])
+                                                    .deleteMany({})];
+                                            case 2:
+                                                _c.sent();
+                                                return [2 /*return*/, repo];
+                                        }
+                                    });
+                                }); },
+                            })];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); }, focus);
+    };
+})();
+db_tests_setup_1.addDatabaseToTest(exports.testMongo, db_tests_setup_1.TestDbs.mongo);
+db_tests_setup_1.addDatabaseToTest(exports.testMongoNoTrans, db_tests_setup_1.TestDbs.mongoNoTrans);
 it('test mongo without transaction', function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
-    var client, mongoDb, db, remult, entity, repo, _a, _b, item, e_1_1, _c, _d;
-    var e_1, _e;
-    return tslib_1.__generator(this, function (_f) {
-        switch (_f.label) {
+    var client, mongoDb, db, remult, entity, repo, _a, _b, item, e_1_1, err_1, _c;
+    var e_1, _d;
+    return tslib_1.__generator(this, function (_e) {
+        switch (_e.label) {
             case 0:
                 client = new mongodb_1.MongoClient('mongodb://localhost:27017/local');
                 return [4 /*yield*/, client.connect()];
             case 1:
-                _f.sent();
+                _e.sent();
                 mongoDb = client.db('test');
                 db = new remult_mongo_1.MongoDataProvider(mongoDb, client, {
                     disableTransactions: true,
@@ -253,63 +284,160 @@ it('test mongo without transaction', function () { return tslib_1.__awaiter(void
                     title: remult3_1.Fields.string(),
                 });
                 repo = remult.repo(entity);
-                _f.label = 2;
+                _e.label = 2;
             case 2:
-                _f.trys.push([2, 8, 9, 10]);
+                _e.trys.push([2, 8, 9, 10]);
                 return [4 /*yield*/, repo.find()];
             case 3:
-                _a = tslib_1.__values.apply(void 0, [_f.sent()]), _b = _a.next();
-                _f.label = 4;
+                _a = tslib_1.__values.apply(void 0, [_e.sent()]), _b = _a.next();
+                _e.label = 4;
             case 4:
                 if (!!_b.done) return [3 /*break*/, 7];
                 item = _b.value;
                 return [4 /*yield*/, repo.delete(item)];
             case 5:
-                _f.sent();
-                _f.label = 6;
+                _e.sent();
+                _e.label = 6;
             case 6:
                 _b = _a.next();
                 return [3 /*break*/, 4];
             case 7: return [3 /*break*/, 10];
             case 8:
-                e_1_1 = _f.sent();
+                e_1_1 = _e.sent();
                 e_1 = { error: e_1_1 };
                 return [3 /*break*/, 10];
             case 9:
                 try {
-                    if (_b && !_b.done && (_e = _a.return)) _e.call(_a);
+                    if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
                 }
                 finally { if (e_1) throw e_1.error; }
                 return [7 /*endfinally*/];
             case 10: return [4 /*yield*/, repo.insert({ id: 1, title: 'a' })];
             case 11:
-                _f.sent();
-                _f.label = 12;
+                _e.sent();
+                _e.label = 12;
             case 12:
-                _f.trys.push([12, 14, , 15]);
-                return [4 /*yield*/, db.transaction(function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+                _e.trys.push([12, 14, , 15]);
+                return [4 /*yield*/, db.transaction(function (dbWithTrans) { 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*/, repo.insert({ id: 2, title: 'b' })];
+                                case 0: return [4 /*yield*/, new context_1.Remult(dbWithTrans).repo(entity).insert({ id: 2, title: 'b' })];
                                 case 1:
                                     _a.sent();
-                                    throw new Error();
+                                    throw 'Error';
                             }
                         });
                     }); })];
             case 13:
-                _f.sent();
+                _e.sent();
                 return [3 /*break*/, 15];
             case 14:
-                _c = _f.sent();
+                err_1 = _e.sent();
+                expect(err_1).toBe('Error');
                 return [3 /*break*/, 15];
             case 15:
-                _d = expect;
+                _c = expect;
                 return [4 /*yield*/, repo.count()];
             case 16:
-                _d.apply(void 0, [_f.sent()]).toBe(2);
+                _c.apply(void 0, [_e.sent()]).toBe(2);
                 return [2 /*return*/];
         }
     });
 }); });
+exports.testMongoNoTrans('transactions mongo no trans', function (_a) {
+    var db = _a.db, createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var x, err_2, _b;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, createEntity(remult_3_entities_1.Categories)];
+                case 1:
+                    x = _c.sent();
+                    _c.label = 2;
+                case 2:
+                    _c.trys.push([2, 4, , 5]);
+                    return [4 /*yield*/, db.transaction(function (db) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+                            var remult, _a;
+                            return tslib_1.__generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        remult = new context_1.Remult(db);
+                                        return [4 /*yield*/, remult.repo(remult_3_entities_1.Categories).insert({ categoryName: 'testing' })];
+                                    case 1:
+                                        _b.sent();
+                                        _a = expect;
+                                        return [4 /*yield*/, remult.repo(remult_3_entities_1.Categories).count()];
+                                    case 2:
+                                        _a.apply(void 0, [_b.sent()]).toBe(1);
+                                        throw 'Fail';
+                                }
+                            });
+                        }); })];
+                case 3:
+                    _c.sent();
+                    return [3 /*break*/, 5];
+                case 4:
+                    err_2 = _c.sent();
+                    expect(err_2).toBe('Fail');
+                    return [3 /*break*/, 5];
+                case 5:
+                    _b = expect;
+                    return [4 /*yield*/, x.count()];
+                case 6:
+                    _b.apply(void 0, [_c.sent()]).toBe(1);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}, 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/src/shared-tests/db-tests-setup.d.ts

@@ -12,7 +12,9 @@ export declare function addDatabaseToTest(tester: dbTestMethodSignature, key?: s
 export declare function testInMemory(key: string, what: dbTestWhatSignature, focus?: boolean): void;
 export declare const TestDbs: {
     restDataProvider: string;
+    webSql: string;
     mongo: string;
+    mongoNoTrans: string;
     inMemory: string;
 };
 export declare type dbTestWhatSignature = (db: {

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

@@ -87,7 +87,9 @@ function testInMemory(key, what, focus) {
 exports.testInMemory = testInMemory;
 exports.TestDbs = {
     restDataProvider: 'restDataProvider',
+    webSql: 'webSql',
     mongo: 'mongo',
+    mongoNoTrans: 'mongoNoTrans',
     inMemory: 'in memory',
 };
 addDatabaseToTest(testInMemory, exports.TestDbs.inMemory);

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

@@ -1814,20 +1814,20 @@ db_tests_setup_1.testAll('task with enum string', function (_a) {
 db_tests_setup_1.testAll('test transaction rollback', function (_a) {
     var db = _a.db, createEntity = _a.createEntity;
     return tslib_1.__awaiter(void 0, void 0, void 0, function () {
-        var fail, r, _b, _c;
-        return tslib_1.__generator(this, function (_d) {
-            switch (_d.label) {
+        var fail, r, err_3, _b;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
                 case 0:
                     fail = true;
                     return [4 /*yield*/, createEntity(stam)];
                 case 1:
-                    r = _d.sent();
+                    r = _c.sent();
                     return [4 /*yield*/, r.insert({ title: 'task b', id: 1 })];
                 case 2:
-                    _d.sent();
-                    _d.label = 3;
+                    _c.sent();
+                    _c.label = 3;
                 case 3:
-                    _d.trys.push([3, 5, , 6]);
+                    _c.trys.push([3, 5, , 6]);
                     return [4 /*yield*/, db.transaction(function (db) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
                             var remultWithTransaction, _a;
                             return tslib_1.__generator(this, function (_b) {
@@ -1846,23 +1846,116 @@ db_tests_setup_1.testAll('test transaction rollback', function (_a) {
                             });
                         }); })];
                 case 4:
-                    _d.sent();
+                    _c.sent();
                     fail = false;
                     return [3 /*break*/, 6];
                 case 5:
-                    _b = _d.sent();
+                    err_3 = _c.sent();
+                    expect(err_3).toBe('error');
                     return [3 /*break*/, 6];
                 case 6:
-                    _c = expect;
+                    _b = expect;
                     return [4 /*yield*/, r.count()];
                 case 7:
-                    _c.apply(void 0, [_d.sent()]).toBe(1);
+                    _b.apply(void 0, [_c.sent()]).toBe(1);
                     expect(fail).toBe(true);
                     return [2 /*return*/];
             }
         });
     });
-}, false, { exclude: [db_tests_setup_1.TestDbs.inMemory] });
+}, false, {
+    exclude: [
+        db_tests_setup_1.TestDbs.inMemory,
+        db_tests_setup_1.TestDbs.mongoNoTrans,
+        db_tests_setup_1.TestDbs.restDataProvider,
+        db_tests_setup_1.TestDbs.webSql,
+    ],
+});
+db_tests_setup_1.testAll('transactions', function (_a) {
+    var db = _a.db, createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var x;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, createEntity(remult_3_entities_1.Categories)];
+                case 1:
+                    x = _b.sent();
+                    return [4 /*yield*/, db.transaction(function (db) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+                            var remult, _a;
+                            return tslib_1.__generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        remult = new context_1.Remult(db);
+                                        _a = expect;
+                                        return [4 /*yield*/, remult.repo(remult_3_entities_1.Categories).count()];
+                                    case 1:
+                                        _a.apply(void 0, [_b.sent()]).toBe(0);
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); })];
+                case 2:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}, false, {
+    exclude: [db_tests_setup_1.TestDbs.mongoNoTrans, db_tests_setup_1.TestDbs.restDataProvider, db_tests_setup_1.TestDbs.webSql],
+});
+db_tests_setup_1.testAll('transactions 1', function (_a) {
+    var db = _a.db, createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var x, err_4, _b;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, createEntity(remult_3_entities_1.Categories)];
+                case 1:
+                    x = _c.sent();
+                    _c.label = 2;
+                case 2:
+                    _c.trys.push([2, 4, , 5]);
+                    return [4 /*yield*/, db.transaction(function (db) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+                            var remult, _a;
+                            return tslib_1.__generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        remult = new context_1.Remult(db);
+                                        return [4 /*yield*/, remult.repo(remult_3_entities_1.Categories).insert({ categoryName: 'testing' })];
+                                    case 1:
+                                        _b.sent();
+                                        _a = expect;
+                                        return [4 /*yield*/, remult.repo(remult_3_entities_1.Categories).count()];
+                                    case 2:
+                                        _a.apply(void 0, [_b.sent()]).toBe(1);
+                                        throw 'Fail';
+                                }
+                            });
+                        }); })];
+                case 3:
+                    _c.sent();
+                    return [3 /*break*/, 5];
+                case 4:
+                    err_4 = _c.sent();
+                    expect(err_4).toBe('Fail');
+                    return [3 /*break*/, 5];
+                case 5:
+                    _b = expect;
+                    return [4 /*yield*/, x.count()];
+                case 6:
+                    _b.apply(void 0, [_c.sent()]).toBe(0);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}, false, {
+    exclude: [
+        db_tests_setup_1.TestDbs.inMemory,
+        db_tests_setup_1.TestDbs.mongoNoTrans,
+        db_tests_setup_1.TestDbs.restDataProvider,
+        db_tests_setup_1.TestDbs.webSql,
+    ],
+});
 db_tests_setup_1.testAll('test date', function (_a) {
     var createEntity = _a.createEntity;
     return tslib_1.__awaiter(void 0, void 0, void 0, function () {
@@ -1968,7 +2061,7 @@ db_tests_setup_1.testAll('test contains with names with casing', function (_a) {
         });
     });
 }, false, {
-    exclude: [db_tests_setup_1.TestDbs.mongo],
+    exclude: [db_tests_setup_1.TestDbs.mongo, db_tests_setup_1.TestDbs.mongoNoTrans],
 });
 db_tests_setup_1.testAll('test live query storage', function (x) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
     var s, entityKey, id;
@@ -2218,7 +2311,7 @@ db_tests_setup_1.testAll('test json structure 3', function (_a) {
         });
     });
 }, false, {
-    exclude: [db_tests_setup_1.TestDbs.mongo],
+    exclude: [db_tests_setup_1.TestDbs.mongo, db_tests_setup_1.TestDbs.mongoNoTrans],
 });
 db_tests_setup_1.testAll('test relation to number id', function (_a) {
     var createEntity = _a.createEntity;
@@ -2283,4 +2376,4 @@ db_tests_setup_1.testAll('test relation to number id', function (_a) {
             }
         });
     });
-}, false, { exclude: [db_tests_setup_1.TestDbs.mongo] });
+}, false, { exclude: [db_tests_setup_1.TestDbs.mongo, db_tests_setup_1.TestDbs.mongoNoTrans] });

package/src/tests/frontend-database-tests-setup.spec.js

@@ -71,7 +71,7 @@ function testWebSqlImpl(key, what, focus) {
     }); }, focus);
 }
 exports.testWebSqlImpl = testWebSqlImpl;
-db_tests_setup_1.addDatabaseToTest(testWebSqlImpl);
+db_tests_setup_1.addDatabaseToTest(testWebSqlImpl, db_tests_setup_1.TestDbs.webSql);
 function testRest(key, what, focus) {
     var _this = this;
     if (focus === void 0) { focus = false; }