@naturalcycles/db-lib 8.60.0 → 9.0.0

package/src/testing/dbTest.ts

@@ -1,68 +1,21 @@
-import { pDelay, pMap, _filterObject, _pick, _sortBy } from '@naturalcycles/js-lib'
+import { _filterObject, _pick, _sortBy, pMap } from '@naturalcycles/js-lib'
 import { readableToArray } from '@naturalcycles/nodejs-lib'
-import { CommonDB } from '../common.db'
+import { CommonDB, CommonDBType } from '../common.db'
 import { DBIncrement, DBPatch } from '../db.model'
 import { DBQuery } from '../query/dbQuery'
-import { DBTransaction } from '../transaction/dbTransaction'
 import {
   createTestItemDBM,
   createTestItemsDBM,
-  TestItemDBM,
   TEST_TABLE,
+  TestItemDBM,
   testItemDBMJsonSchema,
 } from './test.model'
 import { deepFreeze } from './test.util'
 
-export interface CommonDBImplementationFeatures {
-  /**
-   * All querying functionality.
-   */
-  querying?: boolean
-
-  dbQueryFilter?: boolean
-  dbQueryFilterIn?: boolean
-  dbQueryOrder?: boolean
-  dbQuerySelectFields?: boolean
-  insert?: boolean
-  update?: boolean
-
-  updateByQuery?: boolean
-
-  dbIncrement?: boolean
-
-  createTable?: boolean
-  tableSchemas?: boolean
-
-  /**
-   * Queries should return fresh results immediately.
-   * Datastore is the one known to NOT have strong consistency for queries (not for getById though).
-   */
-  strongConsistency?: boolean
-
-  streaming?: boolean
-
-  bufferSupport?: boolean
-  nullValues?: boolean
-
-  /**
-   * Set false for SQL (relational) databases,
-   * they will return `null` for all missing properties.
-   */
-  documentDB?: boolean
-
-  transactions?: boolean
-}
-
 /**
  * All options default to `false`.
  */
 export interface CommonDBImplementationQuirks {
-  /**
-   * Applicable to e.g Datastore.
-   * Time in milliseconds to wait for eventual consistency to propagate.
-   */
-  eventualConsistencyDelay?: number
-
   /**
    * Example: airtableId
    */
@@ -74,40 +27,8 @@ export interface CommonDBImplementationQuirks {
   allowBooleansAsUndefined?: boolean
 }
 
-/**
- * All unclaimed features will default to 'true'
- */
-export function runCommonDBTest(
-  db: CommonDB,
-  features: CommonDBImplementationFeatures = {},
-  quirks: CommonDBImplementationQuirks = {},
-): void {
-  const {
-    querying = true,
-    tableSchemas = true,
-    createTable = true,
-    dbQueryFilter = true,
-    // dbQueryFilterIn = true,
-    dbQueryOrder = true,
-    dbQuerySelectFields = true,
-    insert = true,
-    update = true,
-    updateByQuery = true,
-    dbIncrement = true,
-    streaming = true,
-    strongConsistency = true,
-    bufferSupport = true,
-    nullValues = true,
-    documentDB = true,
-    transactions = true,
-  } = features
-
-  // const {
-  // allowExtraPropertiesInResponse,
-  // allowBooleansAsUndefined,
-  // } = quirks
-  const eventualConsistencyDelay = !strongConsistency && quirks.eventualConsistencyDelay
-
+export function runCommonDBTest(db: CommonDB, quirks: CommonDBImplementationQuirks = {}): void {
+  const { support } = db
   const items = createTestItemsDBM(3)
   deepFreeze(items)
   const item1 = items[0]!
@@ -119,13 +40,13 @@ export function runCommonDBTest(
   })
 
   // CREATE TABLE, DROP
-  if (createTable) {
+  if (support.createTable) {
     test('createTable, dropIfExists=true', async () => {
       await db.createTable(TEST_TABLE, testItemDBMJsonSchema, { dropIfExists: true })
     })
   }
 
-  if (querying) {
+  if (support.queries) {
     // DELETE ALL initially
     test('deleteByIds test items', async () => {
       const { rows } = await db.runQuery(queryAll().select(['id']))
@@ -139,7 +60,6 @@ export function runCommonDBTest(
 
     // QUERY empty
     test('runQuery(all), runQueryCount should return empty', async () => {
-      if (eventualConsistencyDelay) await pDelay(eventualConsistencyDelay)
       expect((await db.runQuery(queryAll())).rows).toEqual([])
       expect(await db.runQueryCount(queryAll())).toBe(0)
     })
@@ -161,7 +81,7 @@ export function runCommonDBTest(
   })
 
   // SAVE
-  if (nullValues) {
+  if (support.nullValues) {
     test('should allow to save and load null values', async () => {
       const item3 = {
         ...createTestItemDBM(3),
@@ -175,7 +95,7 @@ export function runCommonDBTest(
     })
   }
 
-  if (documentDB) {
+  if (db.dbType === CommonDBType.document) {
     test('undefined values should not be saved/loaded', async () => {
       const item3 = {
         ...createTestItemDBM(3),
@@ -193,7 +113,7 @@ export function runCommonDBTest(
     })
   }
 
-  if (update) {
+  if (support.updateSaveMethod) {
     test('saveBatch UPDATE method should throw', async () => {
       await expect(db.saveBatch(TEST_TABLE, items, { saveMethod: 'update' })).rejects.toThrow()
     })
@@ -207,13 +127,13 @@ export function runCommonDBTest(
     await expect(db.saveBatch(TEST_TABLE, [{ ...item1, id: null as any }])).rejects.toThrow()
   })
 
-  if (insert) {
+  if (support.insertSaveMethod) {
     test('saveBatch INSERT method should throw', async () => {
       await expect(db.saveBatch(TEST_TABLE, items, { saveMethod: 'insert' })).rejects.toThrow()
     })
   }
 
-  if (update) {
+  if (support.updateSaveMethod) {
     test('saveBatch UPDATE method should pass', async () => {
       await db.saveBatch(TEST_TABLE, items, { saveMethod: 'update' })
     })
@@ -230,19 +150,18 @@ export function runCommonDBTest(
   })
 
   // QUERY
-  if (querying) {
+  if (support.queries) {
     test('runQuery(all) should return all items', async () => {
-      if (eventualConsistencyDelay) await pDelay(eventualConsistencyDelay)
       let { rows } = await db.runQuery(queryAll())
       rows = _sortBy(rows, r => r.id) // because query doesn't specify order here
       expectMatch(items, rows, quirks)
     })
 
-    if (dbQueryFilter) {
+    if (support.dbQueryFilter) {
       test('query even=true', async () => {
         const q = new DBQuery<TestItemDBM>(TEST_TABLE).filter('even', '==', true)
         let { rows } = await db.runQuery(q)
-        if (!dbQueryOrder) rows = _sortBy(rows, r => r.id)
+        if (!support.dbQueryOrder) rows = _sortBy(rows, r => r.id)
         expectMatch(
           items.filter(i => i.even),
           rows,
@@ -251,7 +170,7 @@ export function runCommonDBTest(
       })
     }
 
-    if (dbQueryOrder) {
+    if (support.dbQueryOrder) {
       test('query order by k1 desc', async () => {
         const q = new DBQuery<TestItemDBM>(TEST_TABLE).order('k1', true)
         const { rows } = await db.runQuery(q)
@@ -259,7 +178,7 @@ export function runCommonDBTest(
       })
     }
 
-    if (dbQuerySelectFields) {
+    if (support.dbQuerySelectFields) {
       test('projection query with only ids', async () => {
         const q = new DBQuery<TestItemDBM>(TEST_TABLE).select(['id'])
         let { rows } = await db.runQuery(q)
@@ -299,7 +218,7 @@ export function runCommonDBTest(
   }
 
   // STREAM
-  if (streaming) {
+  if (support.streaming) {
     test('streamQuery all', async () => {
       let rows = await readableToArray(db.streamQuery(queryAll()))
 
@@ -313,7 +232,7 @@ export function runCommonDBTest(
     const tables = await db.getTables()
     // console.log({ tables })
 
-    if (tableSchemas) {
+    if (support.tableSchemas) {
       await pMap(tables, async table => {
         const schema = await db.getTableSchema(table)
         // console.log(schema)
@@ -323,21 +242,19 @@ export function runCommonDBTest(
   })
 
   // DELETE BY
-  if (querying && dbQueryFilter) {
+  if (support.queries && support.dbQueryFilter) {
     test('deleteByQuery even=false', async () => {
       const q = new DBQuery<TestItemDBM>(TEST_TABLE).filter('even', '==', false)
       const deleted = await db.deleteByQuery(q)
       expect(deleted).toBe(items.filter(item => !item.even).length)
 
-      if (eventualConsistencyDelay) await pDelay(eventualConsistencyDelay)
-
       expect(await db.runQueryCount(queryAll())).toBe(1)
     })
   }
 
   // BUFFER
-  if (bufferSupport) {
-    test('buffer support', async () => {
+  if (support.bufferValues) {
+    test('buffer values', async () => {
       const s = 'helloWorld 1'
       const b1 = Buffer.from(s)
 
@@ -361,7 +278,7 @@ export function runCommonDBTest(
     })
   }
 
-  if (transactions) {
+  if (support.transactions) {
     test('transaction happy path', async () => {
       // cleanup
       await db.deleteByQuery(queryAll())
@@ -370,12 +287,11 @@ export function runCommonDBTest(
       // save item3 with k1: k1_mod
       // delete item2
       // remaining: item1, item3_with_k1_mod
-      const tx = DBTransaction.create()
-        .saveBatch(TEST_TABLE, items)
-        .save(TEST_TABLE, { ...items[2]!, k1: 'k1_mod' })
-        .deleteById(TEST_TABLE, items[1]!.id)
-
-      await db.commitTransaction(tx)
+      const tx = await db.createTransaction()
+      await db.saveBatch(TEST_TABLE, items, { tx })
+      await db.saveBatch(TEST_TABLE, [{ ...items[2]!, k1: 'k1_mod' }], { tx })
+      await db.deleteByIds(TEST_TABLE, [items[1]!.id], { tx })
+      await tx.commit()
 
       const { rows } = await db.runQuery(queryAll())
       const expected = [items[0], { ...items[2]!, k1: 'k1_mod' }]
@@ -384,11 +300,18 @@ export function runCommonDBTest(
 
     test('transaction rollback', async () => {
       // It should fail on id == null
-      const tx = DBTransaction.create()
-        .deleteById(TEST_TABLE, items[2]!.id)
-        .save(TEST_TABLE, { ...items[0]!, k1: 5, id: null as any })
+      let err: any
+
+      try {
+        const tx = await db.createTransaction()
+        await db.deleteByIds(TEST_TABLE, [items[2]!.id], { tx })
+        await db.saveBatch(TEST_TABLE, [{ ...items[0]!, k1: 5, id: null as any }], { tx })
+        await tx.commit()
+      } catch (err_) {
+        err = err_
+      }
 
-      await expect(db.commitTransaction(tx)).rejects.toThrow()
+      expect(err).toBeDefined()
 
       const { rows } = await db.runQuery(queryAll())
       const expected = [items[0], { ...items[2]!, k1: 'k1_mod' }]
@@ -396,7 +319,7 @@ export function runCommonDBTest(
     })
   }
 
-  if (updateByQuery) {
+  if (support.updateByQuery) {
     test('updateByQuery simple', async () => {
       // cleanup, reset initial data
       await db.deleteByQuery(queryAll())
@@ -419,7 +342,7 @@ export function runCommonDBTest(
       expectMatch(expected, rows, quirks)
     })
 
-    if (dbIncrement) {
+    if (support.dbIncrement) {
       test('updateByQuery DBIncrement', async () => {
         // cleanup, reset initial data
         await db.deleteByQuery(queryAll())
@@ -447,7 +370,7 @@ export function runCommonDBTest(
     }
   }
 
-  if (querying) {
+  if (support.queries) {
     test('cleanup', async () => {
       // CLEAN UP
       await db.deleteByQuery(queryAll())

package/src/testing/index.ts

@@ -1,9 +1,5 @@
 import { runCommonDaoTest } from './daoTest'
-import {
-  CommonDBImplementationFeatures,
-  CommonDBImplementationQuirks,
-  runCommonDBTest,
-} from './dbTest'
+import { CommonDBImplementationQuirks, runCommonDBTest } from './dbTest'
 import { runCommonKeyValueDBTest } from './keyValueDBTest'
 import {
   createTestItemBM,
@@ -21,13 +17,7 @@ import {
   TEST_TABLE,
 } from './test.model'
 
-export type {
-  TestItemDBM,
-  TestItemBM,
-  TestItemTM,
-  CommonDBImplementationFeatures,
-  CommonDBImplementationQuirks,
-}
+export type { TestItemDBM, TestItemBM, TestItemTM, CommonDBImplementationQuirks }
 
 export {
   TEST_TABLE,

package/src/timeseries/commonTimeSeriesDao.ts

@@ -1,5 +1,4 @@
 import { _isTruthy, ObjectWithId } from '@naturalcycles/js-lib'
-import { DBTransaction } from '..'
 import { DBQuery } from '../query/dbQuery'
 import {
   CommonTimeSeriesDaoCfg,
@@ -53,19 +52,19 @@ export class CommonTimeSeriesDao {
   async commitTransaction(ops: TimeSeriesSaveBatchOp[]): Promise<void> {
     if (!ops.length) return
 
-    const tx = DBTransaction.create()
+    const tx = await this.cfg.db.createTransaction()
 
-    ops.forEach(op => {
+    for (const op of ops) {
       const rows: ObjectWithId[] = op.dataPoints.map(([ts, v]) => ({
         id: String(ts), // Convert Number id into String id, as per CommonDB
         ts, // to allow querying by ts, since querying by id is not always available (Datastore is one example)
         v,
       }))
 
-      tx.saveBatch(`${op.series}${_TIMESERIES_RAW}`, rows)
-    })
+      await this.cfg.db.saveBatch(`${op.series}${_TIMESERIES_RAW}`, rows, { tx })
+    }
 
-    await this.cfg.db.commitTransaction(tx)
+    await tx.commit()
   }
 
   async deleteById(series: string, tsMillis: number): Promise<void> {

package/src/transaction/dbTransaction.util.ts

@@ -1,7 +1,7 @@
+import { ObjectWithId } from '@naturalcycles/js-lib'
 import type { CommonDB } from '../common.db'
-import { CommonDBSaveOptions, DBOperation } from '../db.model'
+import { CommonDBOptions, CommonDBSaveOptions, DBTransaction, RunQueryResult } from '../db.model'
 import { DBQuery } from '../query/dbQuery'
-import { DBTransaction } from './dbTransaction'
 
 /**
  * Optimizes the Transaction (list of DBOperations) to do less operations.
@@ -11,9 +11,9 @@ import { DBTransaction } from './dbTransaction'
  * Currently only takes into account SaveBatch and DeleteByIds ops.
  * Output ops are maximum 1 per entity - save or delete.
  */
-export function mergeDBOperations(ops: DBOperation[]): DBOperation[] {
-  return ops // currently "does nothing"
-}
+// export function mergeDBOperations(ops: DBOperation[]): DBOperation[] {
+//   return ops // currently "does nothing"
+// }
 
 // Commented out as "overly complicated"
 /*
@@ -70,23 +70,62 @@ export function mergeDBOperations(ops: DBOperation[]): DBOperation[] {
  * Does NOT actually implement a Transaction, cause partial ops application will happen
  * in case of an error in the middle.
  */
-export async function commitDBTransactionSimple(
-  db: CommonDB,
-  tx: DBTransaction,
-  opt?: CommonDBSaveOptions,
-): Promise<void> {
-  // const ops = mergeDBOperations(tx.ops)
+// export async function commitDBTransactionSimple(
+//   db: CommonDB,
+//   ops: DBOperation[],
+//   opt?: CommonDBSaveOptions,
+// ): Promise<void> {
+//   // const ops = mergeDBOperations(tx.ops)
+//
+//   for await (const op of ops) {
+//     if (op.type === 'saveBatch') {
+//       await db.saveBatch(op.table, op.rows, { ...op.opt, ...opt })
+//     } else if (op.type === 'deleteByIds') {
+//       await db.deleteByQuery(DBQuery.create(op.table).filter('id', 'in', op.ids), {
+//         ...op.opt,
+//         ...opt,
+//       })
+//     } else {
+//       throw new Error(`DBOperation not supported: ${(op as any).type}`)
+//     }
+//   }
+// }
 
-  for await (const op of tx.ops) {
-    if (op.type === 'saveBatch') {
-      await db.saveBatch(op.table, op.rows, { ...op.opt, ...opt })
-    } else if (op.type === 'deleteByIds') {
-      await db.deleteByQuery(DBQuery.create(op.table).filter('id', 'in', op.ids), {
-        ...op.opt,
-        ...opt,
-      })
-    } else {
-      throw new Error(`DBOperation not supported: ${(op as any).type}`)
-    }
+/**
+ * Fake implementation of DBTransactionContext,
+ * which executes all operations instantly, without any Transaction involved.
+ */
+export class FakeDBTransaction implements DBTransaction {
+  constructor(protected db: CommonDB) {}
+
+  async commit(): Promise<void> {}
+  async rollback(): Promise<void> {}
+
+  async getByIds<ROW extends ObjectWithId>(
+    table: string,
+    ids: string[],
+    opt?: CommonDBOptions,
+  ): Promise<ROW[]> {
+    return await this.db.getByIds(table, ids, opt)
+  }
+  async runQuery<ROW extends ObjectWithId>(
+    q: DBQuery<ROW>,
+    opt?: CommonDBOptions,
+  ): Promise<RunQueryResult<ROW>> {
+    return await this.db.runQuery(q, opt)
+  }
+  async saveBatch<ROW extends Partial<ObjectWithId>>(
+    table: string,
+    rows: ROW[],
+    opt?: CommonDBSaveOptions<ROW>,
+  ): Promise<void> {
+    return await this.db.saveBatch(table, rows, opt)
+  }
+  async deleteByIds(
+    table: string,
+    ids: string[],
+    opt?: CommonDBOptions | undefined,
+  ): Promise<number> {
+    return await this.db.deleteByIds(table, ids, opt)
   }
 }

package/src/validation/index.ts

@@ -17,8 +17,8 @@ import {
 } from '../query/dbQuery'
 
 export const commonDBOptionsSchema = objectSchema<CommonDBOptions>({
-  onlyCache: booleanSchema.optional(),
-  skipCache: booleanSchema.optional(),
+  ['onlyCache' as any]: booleanSchema.optional(),
+  ['skipCache' as any]: booleanSchema.optional(),
 })
 
 export const commonDBSaveOptionsSchema = objectSchema<CommonDBSaveOptions>({

package/dist/transaction/dbTransaction.d.ts

@@ -1,27 +0,0 @@
-import { ObjectWithId } from '@naturalcycles/js-lib';
-import type { CommonDB } from '../common.db';
-import type { CommonDBSaveOptions, DBOperation } from '../db.model';
-/**
- * Convenience class that stores the list of DBOperations and provides a fluent API to add them.
- */
-export declare class DBTransaction {
-    ops: DBOperation[];
-    protected constructor(ops?: DBOperation[]);
-    /**
-     * Convenience method.
-     */
-    static create(ops?: DBOperation[]): DBTransaction;
-    save<ROW extends Partial<ObjectWithId>>(table: string, row: ROW): this;
-    saveBatch<ROW extends Partial<ObjectWithId>>(table: string, rows: ROW[]): this;
-    deleteById(table: string, id: string): this;
-    deleteByIds(table: string, ids: string[]): this;
-}
-/**
- * Extends DBTransaction by providing a convenient `commit` method that delegates
- * to CommonDB.commitTransaction().
- */
-export declare class RunnableDBTransaction extends DBTransaction {
-    db: CommonDB;
-    constructor(db: CommonDB);
-    commit<ROW extends Partial<ObjectWithId>>(opt?: CommonDBSaveOptions<ROW>): Promise<void>;
-}

package/dist/transaction/dbTransaction.js

@@ -1,64 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RunnableDBTransaction = exports.DBTransaction = void 0;
-/**
- * Convenience class that stores the list of DBOperations and provides a fluent API to add them.
- */
-class DBTransaction {
-    constructor(ops = []) {
-        this.ops = ops;
-    }
-    /**
-     * Convenience method.
-     */
-    static create(ops = []) {
-        return new DBTransaction(ops);
-    }
-    save(table, row) {
-        this.ops.push({
-            type: 'saveBatch',
-            table,
-            rows: [row],
-        });
-        return this;
-    }
-    saveBatch(table, rows) {
-        this.ops.push({
-            type: 'saveBatch',
-            table,
-            rows,
-        });
-        return this;
-    }
-    deleteById(table, id) {
-        this.ops.push({
-            type: 'deleteByIds',
-            table,
-            ids: [id],
-        });
-        return this;
-    }
-    deleteByIds(table, ids) {
-        this.ops.push({
-            type: 'deleteByIds',
-            table,
-            ids,
-        });
-        return this;
-    }
-}
-exports.DBTransaction = DBTransaction;
-/**
- * Extends DBTransaction by providing a convenient `commit` method that delegates
- * to CommonDB.commitTransaction().
- */
-class RunnableDBTransaction extends DBTransaction {
-    constructor(db) {
-        super();
-        this.db = db;
-    }
-    async commit(opt) {
-        await this.db.commitTransaction(this, opt);
-    }
-}
-exports.RunnableDBTransaction = RunnableDBTransaction;

package/src/transaction/dbTransaction.ts

@@ -1,67 +0,0 @@
-import { ObjectWithId } from '@naturalcycles/js-lib'
-import type { CommonDB } from '../common.db'
-import type { CommonDBSaveOptions, DBOperation } from '../db.model'
-
-/**
- * Convenience class that stores the list of DBOperations and provides a fluent API to add them.
- */
-export class DBTransaction {
-  protected constructor(public ops: DBOperation[] = []) {}
-
-  /**
-   * Convenience method.
-   */
-  static create(ops: DBOperation[] = []): DBTransaction {
-    return new DBTransaction(ops)
-  }
-
-  save<ROW extends Partial<ObjectWithId>>(table: string, row: ROW): this {
-    this.ops.push({
-      type: 'saveBatch',
-      table,
-      rows: [row],
-    })
-    return this
-  }
-
-  saveBatch<ROW extends Partial<ObjectWithId>>(table: string, rows: ROW[]): this {
-    this.ops.push({
-      type: 'saveBatch',
-      table,
-      rows,
-    })
-    return this
-  }
-
-  deleteById(table: string, id: string): this {
-    this.ops.push({
-      type: 'deleteByIds',
-      table,
-      ids: [id],
-    })
-    return this
-  }
-
-  deleteByIds(table: string, ids: string[]): this {
-    this.ops.push({
-      type: 'deleteByIds',
-      table,
-      ids,
-    })
-    return this
-  }
-}
-
-/**
- * Extends DBTransaction by providing a convenient `commit` method that delegates
- * to CommonDB.commitTransaction().
- */
-export class RunnableDBTransaction extends DBTransaction {
-  constructor(public db: CommonDB) {
-    super()
-  }
-
-  async commit<ROW extends Partial<ObjectWithId>>(opt?: CommonDBSaveOptions<ROW>): Promise<void> {
-    await this.db.commitTransaction(this, opt)
-  }
-}