@naturalcycles/db-lib 10.22.0 → 10.23.0

package/dist/commondb/common.db.d.ts

@@ -188,6 +188,7 @@ export interface CommonDBSupport {
     bufferValues?: boolean;
     nullValues?: boolean;
     transactions?: boolean;
+    createTransaction?: boolean;
     timeMachine?: boolean;
     multiTableOperations?: boolean;
 }

package/dist/commondb/common.db.js

@@ -20,6 +20,7 @@ export const commonDBFullSupport = {
     bufferValues: true,
     nullValues: true,
     transactions: true,
+    createTransaction: true,
     timeMachine: true,
     multiTableOperations: true,
 };

package/dist/testing/commonDaoTest.js

@@ -263,36 +263,38 @@ export async function runCommonDaoTest(db, quirks = {}) {
             const expected = [items[0], { ...items[2], k1: 'k1_mod' }];
             expectMatch(expected, rows, quirks);
         });
-        test('createTransaction happy path', async () => {
-            // cleanup
-            await dao.query().deleteByQuery();
-            // Test that id, created, updated are created
-            const now = localTime.nowUnix();
-            const row = _omit(item1, ['id', 'created', 'updated']);
-            let tx = await dao.createTransaction();
-            await tx.save(dao, row);
-            await tx.commit();
-            const loaded = await dao.query().runQuery();
-            expect(loaded.length).toBe(1);
-            expect(loaded[0].id).toBeDefined();
-            expect(loaded[0].created).toBeGreaterThanOrEqual(now);
-            expect(loaded[0].updated).toBe(loaded[0].created);
-            tx = await dao.createTransaction();
-            await tx.deleteById(dao, loaded[0].id);
-            await tx.commit();
-            // saveBatch [item1, 2, 3]
-            // save item3 with k1: k1_mod
-            // delete item2
-            // remaining: item1, item3_with_k1_mod
-            tx = await dao.createTransaction();
-            await tx.saveBatch(dao, items);
-            await tx.save(dao, { ...items[2], k1: 'k1_mod' });
-            await tx.deleteById(dao, items[1].id);
-            await tx.commit();
-            const rows = await dao.query().runQuery();
-            const expected = [items[0], { ...items[2], k1: 'k1_mod' }];
-            expectMatch(expected, rows, quirks);
-        });
+        if (support.createTransaction) {
+            test('createTransaction happy path', async () => {
+                // cleanup
+                await dao.query().deleteByQuery();
+                // Test that id, created, updated are created
+                const now = localTime.nowUnix();
+                const row = _omit(item1, ['id', 'created', 'updated']);
+                let tx = await dao.createTransaction();
+                await tx.save(dao, row);
+                await tx.commit();
+                const loaded = await dao.query().runQuery();
+                expect(loaded.length).toBe(1);
+                expect(loaded[0].id).toBeDefined();
+                expect(loaded[0].created).toBeGreaterThanOrEqual(now);
+                expect(loaded[0].updated).toBe(loaded[0].created);
+                tx = await dao.createTransaction();
+                await tx.deleteById(dao, loaded[0].id);
+                await tx.commit();
+                // saveBatch [item1, 2, 3]
+                // save item3 with k1: k1_mod
+                // delete item2
+                // remaining: item1, item3_with_k1_mod
+                tx = await dao.createTransaction();
+                await tx.saveBatch(dao, items);
+                await tx.save(dao, { ...items[2], k1: 'k1_mod' });
+                await tx.deleteById(dao, items[1].id);
+                await tx.commit();
+                const rows = await dao.query().runQuery();
+                const expected = [items[0], { ...items[2], k1: 'k1_mod' }];
+                expectMatch(expected, rows, quirks);
+            });
+        }
         test('transaction rollback', async () => {
             const expected = await prepare();
             let err;
@@ -310,23 +312,25 @@ export async function runCommonDaoTest(db, quirks = {}) {
             const rows = await dao.query().runQuery();
             expectMatch(expected, rows, quirks);
         });
-        test('createTransaction rollback', async () => {
-            const expected = await prepare();
-            let err;
-            try {
-                const tx = await dao.createTransaction();
-                await tx.deleteById(dao, items[2].id);
-                await tx.save(dao, { ...items[0], k1: 5 }); // it should fail here
-                await tx.commit();
-            }
-            catch (err_) {
-                err = err_;
-            }
-            expect(err).toBeDefined();
-            expect(err).toBeInstanceOf(Error);
-            const rows = await dao.query().runQuery();
-            expectMatch(expected, rows, quirks);
-        });
+        if (support.createTransaction) {
+            test('createTransaction rollback', async () => {
+                const expected = await prepare();
+                let err;
+                try {
+                    const tx = await dao.createTransaction();
+                    await tx.deleteById(dao, items[2].id);
+                    await tx.save(dao, { ...items[0], k1: 5 }); // it should fail here
+                    await tx.commit();
+                }
+                catch (err_) {
+                    err = err_;
+                }
+                expect(err).toBeDefined();
+                expect(err).toBeInstanceOf(Error);
+                const rows = await dao.query().runQuery();
+                expectMatch(expected, rows, quirks);
+            });
+        }
         if (support.queries) {
             test('transaction cleanup', async () => {
                 await dao.query().deleteByQuery();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/db-lib",
   "type": "module",
-  "version": "10.22.0",
+  "version": "10.23.0",
   "dependencies": {
     "@naturalcycles/js-lib": "^15",
     "@naturalcycles/nodejs-lib": "^15"

package/src/commondb/common.db.ts

@@ -273,6 +273,7 @@ export interface CommonDBSupport {
   bufferValues?: boolean
   nullValues?: boolean
   transactions?: boolean
+  createTransaction?: boolean
   timeMachine?: boolean
   multiTableOperations?: boolean
 }
@@ -294,6 +295,7 @@ export const commonDBFullSupport: Required<CommonDBSupport> = {
   bufferValues: true,
   nullValues: true,
   transactions: true,
+  createTransaction: true,
   timeMachine: true,
   multiTableOperations: true,
 }

package/src/testing/commonDaoTest.ts

@@ -358,42 +358,44 @@ export async function runCommonDaoTest(
       expectMatch(expected, rows, quirks)
     })
 
-    test('createTransaction happy path', async () => {
-      // cleanup
-      await dao.query().deleteByQuery()
+    if (support.createTransaction) {
+      test('createTransaction happy path', async () => {
+        // cleanup
+        await dao.query().deleteByQuery()
 
-      // Test that id, created, updated are created
-      const now = localTime.nowUnix()
+        // Test that id, created, updated are created
+        const now = localTime.nowUnix()
 
-      const row = _omit(item1, ['id', 'created', 'updated'])
-      let tx = await dao.createTransaction()
-      await tx.save(dao, row)
-      await tx.commit()
+        const row = _omit(item1, ['id', 'created', 'updated'])
+        let tx = await dao.createTransaction()
+        await tx.save(dao, row)
+        await tx.commit()
 
-      const loaded = await dao.query().runQuery()
-      expect(loaded.length).toBe(1)
-      expect(loaded[0]!.id).toBeDefined()
-      expect(loaded[0]!.created).toBeGreaterThanOrEqual(now)
-      expect(loaded[0]!.updated).toBe(loaded[0]!.created)
+        const loaded = await dao.query().runQuery()
+        expect(loaded.length).toBe(1)
+        expect(loaded[0]!.id).toBeDefined()
+        expect(loaded[0]!.created).toBeGreaterThanOrEqual(now)
+        expect(loaded[0]!.updated).toBe(loaded[0]!.created)
 
-      tx = await dao.createTransaction()
-      await tx.deleteById(dao, loaded[0]!.id)
-      await tx.commit()
+        tx = await dao.createTransaction()
+        await tx.deleteById(dao, loaded[0]!.id)
+        await tx.commit()
 
-      // saveBatch [item1, 2, 3]
-      // save item3 with k1: k1_mod
-      // delete item2
-      // remaining: item1, item3_with_k1_mod
-      tx = await dao.createTransaction()
-      await tx.saveBatch(dao, items)
-      await tx.save(dao, { ...items[2]!, k1: 'k1_mod' })
-      await tx.deleteById(dao, items[1]!.id)
-      await tx.commit()
+        // saveBatch [item1, 2, 3]
+        // save item3 with k1: k1_mod
+        // delete item2
+        // remaining: item1, item3_with_k1_mod
+        tx = await dao.createTransaction()
+        await tx.saveBatch(dao, items)
+        await tx.save(dao, { ...items[2]!, k1: 'k1_mod' })
+        await tx.deleteById(dao, items[1]!.id)
+        await tx.commit()
 
-      const rows = await dao.query().runQuery()
-      const expected = [items[0], { ...items[2]!, k1: 'k1_mod' }]
-      expectMatch(expected, rows, quirks)
-    })
+        const rows = await dao.query().runQuery()
+        const expected = [items[0], { ...items[2]!, k1: 'k1_mod' }]
+        expectMatch(expected, rows, quirks)
+      })
+    }
 
     test('transaction rollback', async () => {
       const expected = await prepare()
@@ -416,25 +418,27 @@ export async function runCommonDaoTest(
       expectMatch(expected, rows, quirks)
     })
 
-    test('createTransaction rollback', async () => {
-      const expected = await prepare()
+    if (support.createTransaction) {
+      test('createTransaction rollback', async () => {
+        const expected = await prepare()
 
-      let err: any
-      try {
-        const tx = await dao.createTransaction()
-        await tx.deleteById(dao, items[2]!.id)
-        await tx.save(dao, { ...items[0]!, k1: 5 as any }) // it should fail here
-        await tx.commit()
-      } catch (err_) {
-        err = err_
-      }
+        let err: any
+        try {
+          const tx = await dao.createTransaction()
+          await tx.deleteById(dao, items[2]!.id)
+          await tx.save(dao, { ...items[0]!, k1: 5 as any }) // it should fail here
+          await tx.commit()
+        } catch (err_) {
+          err = err_
+        }
 
-      expect(err).toBeDefined()
-      expect(err).toBeInstanceOf(Error)
+        expect(err).toBeDefined()
+        expect(err).toBeInstanceOf(Error)
 
-      const rows = await dao.query().runQuery()
-      expectMatch(expected, rows, quirks)
-    })
+        const rows = await dao.query().runQuery()
+        expectMatch(expected, rows, quirks)
+      })
+    }
 
     if (support.queries) {
       test('transaction cleanup', async () => {