@naturalcycles/db-lib 10.21.0 → 10.23.0

package/dist/commondao/common.dao.d.ts

@@ -175,9 +175,9 @@ export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity
     private static multiGetMapByTableById;
     private static prepareMultiGetOutput;
     /**
-     * Very @experimental.
+     * @experimental.
      */
-    static multiDeleteByIds(inputs: DaoWithIds<AnyDao>[], _opt?: CommonDaoOptions): Promise<NonNegativeInteger>;
+    static multiDelete(inputs: (DaoWithId<AnyDao> | DaoWithIds<AnyDao>)[], opt?: CommonDaoOptions): Promise<NonNegativeInteger>;
     static multiSave(inputs: (DaoWithRows<AnyDao> | DaoWithRow<AnyDao>)[], opt?: CommonDaoSaveBatchOptions<any>): Promise<void>;
     createTransaction(opt?: CommonDBTransactionOptions): Promise<CommonDaoTransaction>;
     runInTransaction<T = void>(fn: CommonDaoTransactionFn<T>, opt?: CommonDBTransactionOptions): Promise<T>;

package/dist/commondao/common.dao.js

@@ -854,17 +854,27 @@ export class CommonDao {
         return bmsByProp;
     }
     /**
-     * Very @experimental.
+     * @experimental.
      */
-    static async multiDeleteByIds(inputs, _opt = {}) {
+    static async multiDelete(inputs, opt = {}) {
         if (!inputs.length)
             return 0;
         const { db } = inputs[0].dao.cfg;
         const idsByTable = {};
-        for (const { dao, ids } of inputs) {
-            idsByTable[dao.cfg.table] = ids;
+        for (const input of inputs) {
+            const { dao } = input;
+            const { table } = dao.cfg;
+            dao.requireWriteAccess();
+            dao.requireObjectMutability(opt);
+            idsByTable[table] ||= [];
+            if ('id' in input) {
+                idsByTable[table].push(input.id);
+            }
+            else {
+                idsByTable[table].push(...input.ids);
+            }
         }
-        return await db.multiDelete(idsByTable);
+        return await db.multiDelete(idsByTable, opt);
     }
     static async multiSave(inputs, opt = {}) {
         if (!inputs.length)

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.21.0",
+  "version": "10.23.0",
   "dependencies": {
     "@naturalcycles/js-lib": "^15",
     "@naturalcycles/nodejs-lib": "^15"

package/src/commondao/common.dao.ts

@@ -1139,20 +1139,30 @@ export class CommonDao<
   }
 
   /**
-   * Very @experimental.
+   * @experimental.
    */
-  static async multiDeleteByIds(
-    inputs: DaoWithIds<AnyDao>[],
-    _opt: CommonDaoOptions = {},
+  static async multiDelete(
+    inputs: (DaoWithId<AnyDao> | DaoWithIds<AnyDao>)[],
+    opt: CommonDaoOptions = {},
   ): Promise<NonNegativeInteger> {
     if (!inputs.length) return 0
     const { db } = inputs[0]!.dao.cfg
     const idsByTable: StringMap<string[]> = {}
-    for (const { dao, ids } of inputs) {
-      idsByTable[dao.cfg.table] = ids
+    for (const input of inputs) {
+      const { dao } = input
+      const { table } = dao.cfg
+      dao.requireWriteAccess()
+      dao.requireObjectMutability(opt)
+      idsByTable[table] ||= []
+
+      if ('id' in input) {
+        idsByTable[table].push(input.id)
+      } else {
+        idsByTable[table].push(...input.ids)
+      }
     }
 
-    return await db.multiDelete(idsByTable)
+    return await db.multiDelete(idsByTable, opt)
   }
 
   static async multiSave(

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 () => {