@naturalcycles/db-lib 8.35.0 → 8.37.0

package/src/commondao/common.dao.ts

@@ -15,6 +15,7 @@ import {
   pMap,
   pTimeout,
   Saved,
+  Unsaved,
 } from '@naturalcycles/js-lib'
 import {
   _pipeline,
@@ -59,49 +60,60 @@ const isCI = !!process.env['CI']
  * TM = Transport model (optimized to be sent over the wire)
  */
 export class CommonDao<
-  BM extends Partial<ObjectWithId>,
-  DBM extends ObjectWithId = Saved<BM>,
+  BM extends Partial<ObjectWithId<ID>>,
+  DBM extends ObjectWithId<ID> = Saved<BM>,
   TM = BM,
+  ID extends string | number = DBM['id'],
 > {
-  constructor(public cfg: CommonDaoCfg<BM, DBM, TM>) {
+  constructor(public cfg: CommonDaoCfg<BM, DBM, TM, ID>) {
     this.cfg = {
       // Default is to NOT log in AppEngine and in CI,
       // otherwise to log Operations
       // e.g in Dev (local machine), Test - it will log operations (useful for debugging)
       logLevel: isGAE || isCI ? CommonDaoLogLevel.NONE : CommonDaoLogLevel.OPERATIONS,
+      idType: 'string',
+      createId: true,
       created: true,
       updated: true,
       logger: console,
       ...cfg,
       hooks: {
-        createId: () => stringId(),
         parseNaturalId: () => ({}),
         beforeCreate: bm => bm as BM,
         beforeDBMValidate: dbm => dbm,
         beforeDBMToBM: dbm => dbm as any,
         beforeBMToDBM: bm => bm as any,
-        beforeTMToBM: tm => tm as any,
+        beforeTMToBM: tm => tm,
         beforeBMToTM: bm => bm as any,
         anonymize: dbm => dbm,
         onValidationError: err => err,
         ...cfg.hooks,
       },
     }
+
+    if (this.cfg.createId) {
+      _assert(
+        this.cfg.idType === 'string',
+        'db-lib: automatic generation of non-string ids is not supported',
+      )
+
+      this.cfg.hooks!.createId ||= () => stringId() as ID
+    } else {
+      delete this.cfg.hooks!.createId
+    }
   }
 
   // CREATE
   create(part: Partial<BM> = {}, opt: CommonDaoOptions = {}): Saved<BM> {
     let bm = this.cfg.hooks!.beforeCreate!(part) as BM
     bm = this.validateAndConvert(bm, this.cfg.bmSchema, DBModelType.BM, opt)
-
-    // If no SCHEMA - return as is
     return this.assignIdCreatedUpdated(bm, opt)
   }
 
   // GET
   async getById(id: undefined, opt?: CommonDaoOptions): Promise<null>
-  async getById(id?: string, opt?: CommonDaoOptions): Promise<Saved<BM> | null>
-  async getById(id?: string, opt: CommonDaoOptions = {}): Promise<Saved<BM> | null> {
+  async getById(id?: ID, opt?: CommonDaoOptions): Promise<Saved<BM> | null>
+  async getById(id?: ID, opt: CommonDaoOptions = {}): Promise<Saved<BM> | null> {
     if (!id) return null
     const op = `getById(${id})`
     const table = opt.table || this.cfg.table
@@ -126,22 +138,14 @@ export class CommonDao<
     return bm || null
   }
 
-  async getByIdOrEmpty(
-    id: string,
-    part: Partial<BM> = {},
-    opt?: CommonDaoOptions,
-  ): Promise<Saved<BM>> {
+  async getByIdOrEmpty(id: ID, part: Partial<BM> = {}, opt?: CommonDaoOptions): Promise<Saved<BM>> {
     const bm = await this.getById(id, opt)
     if (bm) return bm
 
     return this.create({ ...part, id }, opt)
   }
 
-  async getByIdAsDBMOrEmpty(
-    id: string,
-    part: Partial<BM> = {},
-    opt?: CommonDaoOptions,
-  ): Promise<DBM> {
+  async getByIdAsDBMOrEmpty(id: ID, part: Partial<BM> = {}, opt?: CommonDaoOptions): Promise<DBM> {
     const dbm = await this.getByIdAsDBM(id, opt)
     if (dbm) return dbm
 
@@ -150,8 +154,8 @@ export class CommonDao<
   }
 
   async getByIdAsDBM(id: undefined, opt?: CommonDaoOptions): Promise<null>
-  async getByIdAsDBM(id?: string, opt?: CommonDaoOptions): Promise<DBM | null>
-  async getByIdAsDBM(id?: string, opt: CommonDaoOptions = {}): Promise<DBM | null> {
+  async getByIdAsDBM(id?: ID, opt?: CommonDaoOptions): Promise<DBM | null>
+  async getByIdAsDBM(id?: ID, opt: CommonDaoOptions = {}): Promise<DBM | null> {
     if (!id) return null
     const op = `getByIdAsDBM(${id})`
     const table = opt.table || this.cfg.table
@@ -165,8 +169,8 @@ export class CommonDao<
   }
 
   async getByIdAsTM(id: undefined, opt?: CommonDaoOptions): Promise<null>
-  async getByIdAsTM(id?: string, opt?: CommonDaoOptions): Promise<TM | null>
-  async getByIdAsTM(id?: string, opt: CommonDaoOptions = {}): Promise<TM | null> {
+  async getByIdAsTM(id?: ID, opt?: CommonDaoOptions): Promise<TM | null>
+  async getByIdAsTM(id?: ID, opt: CommonDaoOptions = {}): Promise<TM | null> {
     if (!id) return null
     const op = `getByIdAsTM(${id})`
     const table = opt.table || this.cfg.table
@@ -182,7 +186,7 @@ export class CommonDao<
     return tm || null
   }
 
-  async getByIds(ids: string[], opt: CommonDaoOptions = {}): Promise<Saved<BM>[]> {
+  async getByIds(ids: ID[], opt: CommonDaoOptions = {}): Promise<Saved<BM>[]> {
     const op = `getByIds ${ids.length} id(s) (${_truncate(ids.slice(0, 10).join(', '), 50)})`
     const table = opt.table || this.cfg.table
     const started = this.logStarted(op, table)
@@ -192,7 +196,7 @@ export class CommonDao<
     return bms
   }
 
-  async getByIdsAsDBM(ids: string[], opt: CommonDaoOptions = {}): Promise<DBM[]> {
+  async getByIdsAsDBM(ids: ID[], opt: CommonDaoOptions = {}): Promise<DBM[]> {
     const op = `getByIdsAsDBM ${ids.length} id(s) (${_truncate(ids.slice(0, 10).join(', '), 50)})`
     const table = opt.table || this.cfg.table
     const started = this.logStarted(op, table)
@@ -201,7 +205,7 @@ export class CommonDao<
     return dbms
   }
 
-  async requireById(id: string, opt: CommonDaoOptions = {}): Promise<Saved<BM>> {
+  async requireById(id: ID, opt: CommonDaoOptions = {}): Promise<Saved<BM>> {
     const r = await this.getById(id, opt)
     if (!r) {
       this.throwRequiredError(id, opt)
@@ -209,7 +213,7 @@ export class CommonDao<
     return r
   }
 
-  async requireByIdAsDBM(id: string, opt: CommonDaoOptions = {}): Promise<DBM> {
+  async requireByIdAsDBM(id: ID, opt: CommonDaoOptions = {}): Promise<DBM> {
     const r = await this.getByIdAsDBM(id, opt)
     if (!r) {
       this.throwRequiredError(id, opt)
@@ -217,7 +221,7 @@ export class CommonDao<
     return r
   }
 
-  private throwRequiredError(id: string, opt: CommonDaoOptions): never {
+  private throwRequiredError(id: ID, opt: CommonDaoOptions): never {
     const table = opt.table || this.cfg.table
     throw new AppError(`DB row required, but not found: ${table}.${id}`, {
       code: DBLibError.DB_ROW_REQUIRED,
@@ -267,8 +271,8 @@ export class CommonDao<
   /**
    * Pass `table` to override table
    */
-  query(table?: string): RunnableDBQuery<BM, DBM, TM> {
-    return new RunnableDBQuery<BM, DBM, TM>(this, table)
+  query(table?: string): RunnableDBQuery<BM, DBM, TM, ID> {
+    return new RunnableDBQuery<BM, DBM, TM, ID>(this, table)
   }
 
   async runQuery(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<Saved<BM>[]> {
@@ -514,18 +518,18 @@ export class CommonDao<
     )
   }
 
-  async queryIds(q: DBQuery<DBM>, opt: CommonDaoOptions = {}): Promise<string[]> {
+  async queryIds(q: DBQuery<DBM>, opt: CommonDaoOptions = {}): Promise<ID[]> {
     q.table = opt.table || q.table
     const { rows } = await this.cfg.db.runQuery(q.select(['id']), opt)
     return rows.map(r => r.id)
   }
 
-  streamQueryIds(q: DBQuery<DBM>, opt: CommonDaoStreamOptions = {}): ReadableTyped<string> {
+  streamQueryIds(q: DBQuery<DBM>, opt: CommonDaoStreamOptions = {}): ReadableTyped<ID> {
     q.table = opt.table || q.table
     opt.errorMode ||= ErrorMode.SUPPRESS
 
     return this.cfg.db.streamQuery<DBM>(q.select(['id']), opt).pipe(
-      transformMapSimple<ObjectWithId, string>(objectWithId => objectWithId.id, {
+      transformMapSimple<DBM, ID>(objectWithId => objectWithId.id, {
         errorMode: ErrorMode.SUPPRESS, // cause .pipe() cannot propagate errors
       }),
     )
@@ -533,8 +537,8 @@ export class CommonDao<
 
   async streamQueryIdsForEach(
     q: DBQuery<DBM>,
-    mapper: AsyncMapper<string, void>,
-    opt: CommonDaoStreamForEachOptions<string> = {},
+    mapper: AsyncMapper<ID, void>,
+    opt: CommonDaoStreamForEachOptions<ID> = {},
   ): Promise<void> {
     q.table = opt.table || q.table
     opt.errorMode = opt.errorMode || ErrorMode.SUPPRESS
@@ -545,9 +549,9 @@ export class CommonDao<
 
     await _pipeline([
       this.cfg.db.streamQuery<DBM>(q.select(['id']), opt),
-      transformMapSimple<ObjectWithId, string>(objectWithId => objectWithId.id),
+      transformMapSimple<DBM, ID>(objectWithId => objectWithId.id),
       transformTap(() => count++),
-      transformMap<string, void>(mapper, {
+      transformMap<ID, void>(mapper, {
         ...opt,
         predicate: _passthroughPredicate,
       }),
@@ -570,21 +574,18 @@ export class CommonDao<
    */
   assignIdCreatedUpdated(obj: DBM, opt?: CommonDaoOptions): DBM
   assignIdCreatedUpdated(obj: BM, opt?: CommonDaoOptions): Saved<BM>
-  assignIdCreatedUpdated(obj: DBM | BM, opt: CommonDaoOptions = {}): DBM | Saved<BM> {
+  assignIdCreatedUpdated(obj: Unsaved<BM>, opt?: CommonDaoOptions): Saved<BM>
+  assignIdCreatedUpdated(obj: DBM | BM | Unsaved<BM>, opt: CommonDaoOptions = {}): DBM | Saved<BM> {
     const now = Math.floor(Date.now() / 1000)
 
-    obj.id = obj.id || this.cfg.hooks!.createId!(obj)
+    obj.id ||= this.cfg.hooks!.createId?.(obj as BM)
 
     if (this.cfg.created) {
-      Object.assign(obj, {
-        created: (obj as any).created || (obj as any).updated || now,
-      })
+      obj['created'] ||= obj['updated'] || now
     }
 
     if (this.cfg.updated) {
-      Object.assign(obj, {
-        updated: opt.preserveUpdatedCreated && (obj as any).updated ? (obj as any).updated : now,
-      })
+      obj['updated'] = opt.preserveUpdatedCreated && obj['updated'] ? obj['updated'] : now
     }
 
     return obj as any
@@ -594,11 +595,11 @@ export class CommonDao<
   /**
    * Mutates with id, created, updated
    */
-  async save(bm: BM, opt: CommonDaoSaveOptions<DBM> = {}): Promise<Saved<BM>> {
+  async save(bm: Unsaved<BM>, opt: CommonDaoSaveOptions<DBM> = {}): Promise<Saved<BM>> {
     this.requireWriteAccess()
     const idWasGenerated = !bm.id
     this.assignIdCreatedUpdated(bm, opt) // mutates
-    const dbm = await this.bmToDBM(bm, opt)
+    const dbm = await this.bmToDBM(bm as BM, opt)
     const table = opt.table || this.cfg.table
     if (opt.ensureUniqueId && idWasGenerated) await this.ensureUniqueId(table, dbm)
     if (this.cfg.immutable) await this.ensureImmutableDontExist(table, [dbm.id])
@@ -613,7 +614,7 @@ export class CommonDao<
     return bm as any
   }
 
-  private async ensureImmutableDontExist(table: string, ids: string[]): Promise<void> {
+  private async ensureImmutableDontExist(table: string, ids: ID[]): Promise<void> {
     await this.throwIfObjectExists(table, ids, [
       DBLibError.OBJECT_IS_IMMUTABLE,
       {
@@ -640,7 +641,7 @@ export class CommonDao<
 
   private async throwIfObjectExists(
     table: string,
-    ids: string[],
+    ids: ID[],
     errorMeta: [DBLibError, any],
   ): Promise<void> {
     const existing = await this.cfg.db.getByIds<DBM>(table, ids)
@@ -656,11 +657,7 @@ export class CommonDao<
    *
    * Convenience method to replace 3 operations (loading+patching+saving) with one.
    */
-  async patch(
-    id: string,
-    patch: Partial<BM>,
-    opt: CommonDaoSaveOptions<DBM> = {},
-  ): Promise<Saved<BM>> {
+  async patch(id: ID, patch: Partial<BM>, opt: CommonDaoSaveOptions<DBM> = {}): Promise<Saved<BM>> {
     return await this.save(
       {
         ...(await this.getByIdOrEmpty(id, patch, opt)),
@@ -670,11 +667,7 @@ export class CommonDao<
     )
   }
 
-  async patchAsDBM(
-    id: string,
-    patch: Partial<DBM>,
-    opt: CommonDaoSaveOptions<DBM> = {},
-  ): Promise<DBM> {
+  async patchAsDBM(id: ID, patch: Partial<DBM>, opt: CommonDaoSaveOptions<DBM> = {}): Promise<DBM> {
     const dbm =
       (await this.getByIdAsDBM(id, opt)) ||
       (this.create({ ...patch, id } as Partial<BM>, opt) as any as DBM)
@@ -711,11 +704,11 @@ export class CommonDao<
     return dbm
   }
 
-  async saveBatch(bms: BM[], opt: CommonDaoSaveOptions<DBM> = {}): Promise<Saved<BM>[]> {
+  async saveBatch(bms: Unsaved<BM>[], opt: CommonDaoSaveOptions<DBM> = {}): Promise<Saved<BM>[]> {
     this.requireWriteAccess()
     const table = opt.table || this.cfg.table
     bms.forEach(bm => this.assignIdCreatedUpdated(bm, opt))
-    const dbms = await this.bmsToDBM(bms, opt)
+    const dbms = await this.bmsToDBM(bms as BM[], opt)
     if (opt.ensureUniqueId) throw new AppError('ensureUniqueId is not supported in saveBatch')
     if (this.cfg.immutable)
       await this.ensureImmutableDontExist(
@@ -778,8 +771,8 @@ export class CommonDao<
    * @returns number of deleted items
    */
   async deleteById(id: undefined, opt?: CommonDaoOptions): Promise<0>
-  async deleteById(id?: string, opt?: CommonDaoOptions): Promise<number>
-  async deleteById(id?: string, opt: CommonDaoOptions = {}): Promise<number> {
+  async deleteById(id?: ID, opt?: CommonDaoOptions): Promise<number>
+  async deleteById(id?: ID, opt: CommonDaoOptions = {}): Promise<number> {
     if (!id) return 0
     this.requireWriteAccess()
     if (!opt.allowMutability) this.requireObjectMutability()
@@ -791,7 +784,7 @@ export class CommonDao<
     return ids
   }
 
-  async deleteByIds(ids: string[], opt: CommonDaoOptions = {}): Promise<number> {
+  async deleteByIds(ids: ID[], opt: CommonDaoOptions = {}): Promise<number> {
     this.requireWriteAccess()
     if (!opt.allowMutability) this.requireObjectMutability()
     const op = `deleteByIds(${ids.join(', ')})`
@@ -823,7 +816,7 @@ export class CommonDao<
 
       await _pipeline([
         this.cfg.db.streamQuery<DBM>(q.select(['id']), opt),
-        transformMapSimple<ObjectWithId, string>(objectWithId => objectWithId.id, {
+        transformMapSimple<DBM, ID>(objectWithId => objectWithId.id, {
           errorMode: ErrorMode.SUPPRESS,
         }),
         transformBuffer<string>({ batchSize }),

package/src/db.model.ts

@@ -1,5 +1,14 @@
 import { AnyObjectWithId, ObjectWithId } from '@naturalcycles/js-lib'
-import { CommonDB } from './common.db'
+
+/**
+ * Similar to SQL INSERT, UPDATE.
+ * Insert will fail if row already exists.
+ * Update will fail if row is missing.
+ * Upsert will auto-detect and use Insert or Update to not fail.
+ *
+ * Default is Upsert.
+ */
+export type CommonDBSaveMethod = 'upsert' | 'insert' | 'update'
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface
 export interface CommonDBOptions {}
@@ -7,17 +16,23 @@ export interface CommonDBOptions {}
 /**
  * All properties default to undefined.
  */
-export interface CommonDBSaveOptions<ROW extends ObjectWithId = AnyObjectWithId>
+export interface CommonDBSaveOptions<ROW extends Partial<ObjectWithId> = AnyObjectWithId>
   extends CommonDBOptions {
   excludeFromIndexes?: (keyof ROW)[]
+
+  /**
+   * Default is `upsert`
+   */
+  saveMethod?: CommonDBSaveMethod
 }
 
 export type CommonDBStreamOptions = CommonDBOptions
 
 export interface CommonDBCreateOptions extends CommonDBOptions {
   /**
-   * @default false
    * Caution! If set to true - will actually DROP the table!
+   *
+   * @default false
    */
   dropIfExists?: boolean
 }
@@ -51,19 +66,3 @@ export enum DBModelType {
   BM = 'BM',
   TM = 'TM',
 }
-
-/**
- * Interface for a module (lib) that implements CommonDB.
- *
- * Example:
- *
- * const lib: CommonDBModule = require('mysql-lib')
- * const db = lib.getDB()
- */
-export interface CommonDBAdapter {
-  /**
-   * @param cfg was read from SECRET_DB${i} by secret('SECRET_DB${i}') method and passed there.
-   * It's a string that can contain e.g JSON.stringified configuration object (depends on the adapter).
-   */
-  getDBAdapter(cfg?: string): CommonDB
-}

package/src/index.ts

@@ -6,27 +6,19 @@ import { DBLibError } from './cnst'
 import { CommonDB } from './common.db'
 import { CommonDao } from './commondao/common.dao'
 import {
-  CommonDaoAnonymizeHook,
-  CommonDaoBeforeBMToDBMHook,
-  CommonDaoBeforeBMToTMHook,
-  CommonDaoBeforeCreateHook,
-  CommonDaoBeforeDBMToBMHook,
-  CommonDaoBeforeDBMValidateHook,
-  CommonDaoBeforeTMToBMHook,
   CommonDaoCfg,
-  CommonDaoCreateIdHook,
   CommonDaoCreateOptions,
   CommonDaoLogLevel,
   CommonDaoOptions,
-  CommonDaoParseNaturalIdHook,
   CommonDaoSaveOptions,
   CommonDaoStreamForEachOptions,
   CommonDaoStreamOptions,
+  CommonDaoHooks,
 } from './commondao/common.dao.model'
 import {
-  CommonDBAdapter,
   CommonDBCreateOptions,
   CommonDBOptions,
+  CommonDBSaveMethod,
   CommonDBSaveOptions,
   CommonDBStreamOptions,
   DBDeleteByIdsOperation,
@@ -68,28 +60,20 @@ export type {
   CommonDaoSaveOptions,
   CommonDaoStreamForEachOptions,
   CommonDaoStreamOptions,
+  CommonDaoHooks,
   CommonDBOptions,
   CommonDBSaveOptions,
+  CommonDBSaveMethod,
   CommonDBStreamOptions,
   CommonDBCreateOptions,
   CommonDB,
   RunQueryResult,
   CommonDaoCfg,
-  CommonDaoCreateIdHook,
-  CommonDaoParseNaturalIdHook,
-  CommonDaoBeforeCreateHook,
-  CommonDaoBeforeDBMValidateHook,
-  CommonDaoBeforeDBMToBMHook,
-  CommonDaoBeforeBMToDBMHook,
-  CommonDaoBeforeTMToBMHook,
-  CommonDaoBeforeBMToTMHook,
-  CommonDaoAnonymizeHook,
   InMemoryDBCfg,
   InMemoryKeyValueDBCfg,
   DBPipelineBackupOptions,
   DBPipelineRestoreOptions,
   DBPipelineCopyOptions,
-  CommonDBAdapter,
   DBOperation,
   DBSaveBatchOperation,
   DBDeleteByIdsOperation,

package/src/model.util.ts

@@ -1,5 +1,5 @@
 import { stringId } from '@naturalcycles/nodejs-lib'
-import { CreatedUpdated, CreatedUpdatedId, ObjectWithId } from '@naturalcycles/js-lib'
+import { CreatedUpdated, CreatedUpdatedId } from '@naturalcycles/js-lib'
 
 export function createdUpdatedFields(
   existingObject?: Partial<CreatedUpdated> | null,
@@ -12,8 +12,8 @@ export function createdUpdatedFields(
 }
 
 export function createdUpdatedIdFields(
-  existingObject?: Partial<CreatedUpdatedId> | null,
-): CreatedUpdatedId {
+  existingObject?: Partial<CreatedUpdatedId<string>> | null,
+): CreatedUpdatedId<string> {
   const now = Math.floor(Date.now() / 1000)
   return {
     created: existingObject?.created || now,
@@ -22,12 +22,6 @@ export function createdUpdatedIdFields(
   }
 }
 
-export function idField(existingObject?: Partial<CreatedUpdatedId> | null): ObjectWithId {
-  return {
-    id: existingObject?.id || stringId(),
-  }
-}
-
 export function deserializeJsonField<T = any>(f?: string): T {
   return JSON.parse(f || '{}')
 }

package/src/query/dbQuery.ts

@@ -216,14 +216,15 @@ export class DBQuery<ROW extends ObjectWithId = AnyObjectWithId> {
  * DBQuery that has additional method to support Fluent API style.
  */
 export class RunnableDBQuery<
-  BM extends Partial<ObjectWithId>,
-  DBM extends ObjectWithId,
+  BM extends Partial<ObjectWithId<ID>>,
+  DBM extends ObjectWithId<ID>,
   TM,
+  ID extends string | number,
 > extends DBQuery<DBM> {
   /**
    * Pass `table` to override table.
    */
-  constructor(public dao: CommonDao<BM, DBM, TM>, table?: string) {
+  constructor(public dao: CommonDao<BM, DBM, TM, ID>, table?: string) {
     super(table || dao.cfg.table)
   }
 
@@ -281,17 +282,17 @@ export class RunnableDBQuery<
     return this.dao.streamQueryAsDBM(this, opt)
   }
 
-  async queryIds(opt?: CommonDaoOptions): Promise<string[]> {
+  async queryIds(opt?: CommonDaoOptions): Promise<ID[]> {
     return await this.dao.queryIds(this, opt)
   }
 
-  streamQueryIds(opt?: CommonDaoStreamOptions): ReadableTyped<string> {
+  streamQueryIds(opt?: CommonDaoStreamOptions): ReadableTyped<ID> {
     return this.dao.streamQueryIds(this, opt)
   }
 
   async streamQueryIdsForEach(
-    mapper: AsyncMapper<string, void>,
-    opt?: CommonDaoStreamForEachOptions<string>,
+    mapper: AsyncMapper<ID, void>,
+    opt?: CommonDaoStreamForEachOptions<ID>,
   ): Promise<void> {
     await this.dao.streamQueryIdsForEach(this, mapper, opt)
   }

package/src/testing/dbTest.ts

@@ -21,6 +21,8 @@ export interface CommonDBImplementationFeatures {
   dbQueryFilterIn?: boolean
   dbQueryOrder?: boolean
   dbQuerySelectFields?: boolean
+  insert?: boolean
+  update?: boolean
 
   createTable?: boolean
   tableSchemas?: boolean
@@ -80,6 +82,8 @@ export function runCommonDBTest(
     // dbQueryFilterIn = true,
     dbQueryOrder = true,
     dbQuerySelectFields = true,
+    insert = true,
+    update = true,
     streaming = true,
     strongConsistency = true,
     bufferSupport = true,
@@ -176,10 +180,28 @@ export function runCommonDBTest(
     })
   }
 
+  if (update) {
+    test('saveBatch UPDATE method should throw', async () => {
+      await expect(db.saveBatch(TEST_TABLE, items, { saveMethod: 'update' })).rejects.toThrow()
+    })
+  }
+
   test('saveBatch test items', async () => {
     await db.saveBatch(TEST_TABLE, items)
   })
 
+  if (insert) {
+    test('saveBatch INSERT method should throw', async () => {
+      await expect(db.saveBatch(TEST_TABLE, items, { saveMethod: 'insert' })).rejects.toThrow()
+    })
+  }
+
+  if (update) {
+    test('saveBatch UPDATE method should pass', async () => {
+      await db.saveBatch(TEST_TABLE, items, { saveMethod: 'update' })
+    })
+  }
+
   // GET not empty
   test('getByIds all items', async () => {
     const rows = await db.getByIds<TestItemDBM>(TEST_TABLE, items.map(i => i.id).concat('abcd'))

package/dist/adapter/inmemory/index.d.ts

@@ -1,3 +0,0 @@
-import { CommonDB } from '../../common.db';
-export declare function getDBAdapter(): CommonDB;
-export {};

package/dist/adapter/inmemory/index.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDBAdapter = void 0;
-const inMemory_db_1 = require("./inMemory.db");
-function getDBAdapter() {
-    return new inMemory_db_1.InMemoryDB();
-}
-exports.getDBAdapter = getDBAdapter;

package/src/adapter/inmemory/index.ts

@@ -1,9 +0,0 @@
-import { CommonDB } from '../../common.db'
-import { InMemoryDB } from './inMemory.db'
-
-export function getDBAdapter(): CommonDB {
-  return new InMemoryDB()
-}
-
-export // InMemoryDB, // no, otherwise it's double-exported, which can confuse IDEs
- {}