@naturalcycles/db-lib 8.56.0 → 8.58.0

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

@@ -111,10 +111,16 @@ export declare class CommonDao<BM extends Partial<ObjectWithId<ID>>, DBM extends
      * 1.1 Creates the row (via this.create()) if it doesn't exist
      * (this will cause a validation error if Patch has not enough data for the row to be valid).
      * 2. Applies the patch on top of loaded data.
-     * 3. Saves (as fast as possible since the read) with the Patch applied.
+     * 3. Saves (as fast as possible since the read) with the Patch applied, but only if the data has changed.
      */
-    patch(id: ID, patch: Partial<BM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>>;
-    patchAsDBM(id: ID, patch: Partial<DBM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<DBM>;
+    patchById(id: ID, patch: Partial<BM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>>;
+    /**
+     * Same as patchById, but takes the whole object as input.
+     * This "whole object" is mutated with the patch and returned.
+     * Otherwise, similar behavior as patchById.
+     * It still loads the row from the DB.
+     */
+    patch(bm: Saved<BM>, patch: Partial<BM>, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>>;
     saveAsDBM(dbm: DBM, opt?: CommonDaoSaveBatchOptions<DBM>): Promise<DBM>;
     saveBatch(bms: Unsaved<BM>[], opt?: CommonDaoSaveBatchOptions<DBM>): Promise<Saved<BM>[]>;
     saveBatchAsDBM(dbms: DBM[], opt?: CommonDaoSaveBatchOptions<DBM>): Promise<DBM[]>;

package/dist/commondao/common.dao.js

@@ -620,19 +620,16 @@ class CommonDao {
      * 1.1 Creates the row (via this.create()) if it doesn't exist
      * (this will cause a validation error if Patch has not enough data for the row to be valid).
      * 2. Applies the patch on top of loaded data.
-     * 3. Saves (as fast as possible since the read) with the Patch applied.
+     * 3. Saves (as fast as possible since the read) with the Patch applied, but only if the data has changed.
      */
-    async patch(id, patch, opt = {}) {
-        const bm = await this.getById(id, opt);
+    async patchById(id, patch, opt = {}) {
         let patched;
-        if (bm) {
-            patched = {
-                ...bm,
-                ...patch,
-            };
-            if ((0, js_lib_1._deepJsonEquals)(bm, patched)) {
+        const loaded = await this.getById(id, opt);
+        if (loaded) {
+            patched = { ...loaded, ...patch };
+            if ((0, js_lib_1._deepJsonEquals)(loaded, patched)) {
                 // Skipping the save operation, as data is the same
-                return bm;
+                return patched;
             }
         }
         else {
@@ -640,23 +637,30 @@ class CommonDao {
         }
         return await this.save(patched, opt);
     }
-    async patchAsDBM(id, patch, opt = {}) {
-        const dbm = await this.getByIdAsDBM(id, opt);
-        let patched;
-        if (dbm) {
-            patched = {
-                ...dbm,
-                ...patch,
-            };
-            if ((0, js_lib_1._deepJsonEquals)(dbm, patched)) {
+    /**
+     * Same as patchById, but takes the whole object as input.
+     * This "whole object" is mutated with the patch and returned.
+     * Otherwise, similar behavior as patchById.
+     * It still loads the row from the DB.
+     */
+    async patch(bm, patch, opt = {}) {
+        (0, js_lib_1._assert)(bm.id, 'patch argument object should have an id', {
+            bm,
+        });
+        const loaded = await this.getById(bm.id, opt);
+        if (loaded) {
+            Object.assign(loaded, patch);
+            if ((0, js_lib_1._deepJsonEquals)(loaded, bm)) {
                 // Skipping the save operation, as data is the same
-                return dbm;
+                return bm;
             }
+            // Make `bm` exactly the same as `loaded`
+            (0, js_lib_1._objectAssignExact)(bm, loaded);
         }
         else {
-            patched = this.create({ ...patch, id }, opt);
+            Object.assign(bm, patch);
         }
-        return await this.saveAsDBM(patched, opt);
+        return await this.save(bm, opt);
     }
     async saveAsDBM(dbm, opt = {}) {
         this.requireWriteAccess();

package/dist/pipeline/dbPipelineBackup.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { ZlibOptions } from 'node:zlib';
-import { AsyncMapper, ErrorMode } from '@naturalcycles/js-lib';
+import { AsyncMapper, ErrorMode, UnixTimestampNumber, StringMap } from '@naturalcycles/js-lib';
 import { NDJsonStats, TransformLogProgressOptions, TransformMapOptions } from '@naturalcycles/nodejs-lib';
 import { CommonDB } from '../common.db';
 export interface DBPipelineBackupOptions extends TransformLogProgressOptions {
@@ -33,10 +33,13 @@ export interface DBPipelineBackupOptions extends TransformLogProgressOptions {
     limit?: number;
     /**
      * If set - will do "incremental backup" (not full), only for entities that updated >= `sinceUpdated`
-     *
-     * @default undefined
      */
-    sinceUpdated?: number;
+    sinceUpdated?: UnixTimestampNumber;
+    /**
+     * Map for each table a `sinceUpdated` timestamp, or `undefined`.
+     * If set - will do "incremental backup" (not full), only for entities that updated >= `sinceUpdated` (on a per table basis)
+     */
+    sinceUpdatedPerTable?: StringMap<UnixTimestampNumber>;
     /**
      * Directory path to store dumped files. Will create `${tableName}.ndjson` (or .ndjson.gz if gzip=true) files.
      * All parent directories will be created.
@@ -63,7 +66,7 @@ export interface DBPipelineBackupOptions extends TransformLogProgressOptions {
      * @default `{}`
      * Default mappers will be "passthroughMapper" (pass all data as-is).
      */
-    mapperPerTable?: Record<string, AsyncMapper>;
+    mapperPerTable?: StringMap<AsyncMapper>;
     /**
      * You can alter default `transformMapOptions` here.
      *

package/dist/pipeline/dbPipelineBackup.js

@@ -18,17 +18,21 @@ const index_1 = require("../index");
  * Optionally you can provide mapperPerTable and @param transformMapOptions (one for all mappers) - it will run for each table.
  */
 async function dbPipelineBackup(opt) {
-    const { db, concurrency = 16, limit = 0, sinceUpdated, outputDirPath, protectFromOverwrite = false, zlibOptions, mapperPerTable = {}, transformMapOptions, errorMode = js_lib_1.ErrorMode.SUPPRESS, emitSchemaFromDB = false, sortObjects = false, } = opt;
+    const { db, concurrency = 16, limit = 0, outputDirPath, protectFromOverwrite = false, zlibOptions, mapperPerTable = {}, transformMapOptions, errorMode = js_lib_1.ErrorMode.SUPPRESS, emitSchemaFromDB = false, sortObjects = false, } = opt;
     const strict = errorMode !== js_lib_1.ErrorMode.SUPPRESS;
     const gzip = opt.gzip !== false; // default to true
     let { tables } = opt;
-    const sinceUpdatedStr = sinceUpdated ? ' since ' + (0, nodejs_lib_1.grey)((0, js_lib_1.localTime)(sinceUpdated).toPretty()) : '';
-    console.log(`>> ${(0, nodejs_lib_1.dimWhite)('dbPipelineBackup')} started in ${(0, nodejs_lib_1.grey)(outputDirPath)}...${sinceUpdatedStr}`);
+    console.log(`>> ${(0, nodejs_lib_1.dimWhite)('dbPipelineBackup')} started in ${(0, nodejs_lib_1.grey)(outputDirPath)}...`);
     (0, nodejs_lib_1._ensureDirSync)(outputDirPath);
     tables ||= await db.getTables();
     console.log(`${(0, nodejs_lib_1.yellow)(tables.length)} ${(0, nodejs_lib_1.boldWhite)('table(s)')}:\n` + tables.join('\n'));
     const statsPerTable = {};
     await (0, js_lib_1.pMap)(tables, async (table) => {
+        const sinceUpdated = opt.sinceUpdatedPerTable?.[table] || opt.sinceUpdated;
+        const sinceUpdatedStr = sinceUpdated
+            ? ' since ' + (0, nodejs_lib_1.grey)((0, js_lib_1.localTime)(sinceUpdated).toPretty())
+            : '';
+        console.log(`>> ${(0, nodejs_lib_1.grey)(table)}${sinceUpdatedStr}`);
         let q = index_1.DBQuery.create(table).limit(limit);
         if (sinceUpdated) {
             q = q.filter('updated', '>=', sinceUpdated);

package/package.json

@@ -40,7 +40,7 @@
   "engines": {
     "node": ">=18.12"
   },
-  "version": "8.56.0",
+  "version": "8.58.0",
   "description": "Lowest Common Denominator API to supported Databases",
   "keywords": [
     "db",

package/src/commondao/common.dao.ts

@@ -5,6 +5,7 @@ import {
   _filterNullishValues,
   _filterUndefinedValues,
   _isTruthy,
+  _objectAssignExact,
   _passthroughPredicate,
   _since,
   _truncate,
@@ -844,25 +845,22 @@ export class CommonDao<
    * 1.1 Creates the row (via this.create()) if it doesn't exist
    * (this will cause a validation error if Patch has not enough data for the row to be valid).
    * 2. Applies the patch on top of loaded data.
-   * 3. Saves (as fast as possible since the read) with the Patch applied.
+   * 3. Saves (as fast as possible since the read) with the Patch applied, but only if the data has changed.
    */
-  async patch(
+  async patchById(
     id: ID,
     patch: Partial<BM>,
     opt: CommonDaoSaveBatchOptions<DBM> = {},
   ): Promise<Saved<BM>> {
-    const bm = await this.getById(id, opt)
     let patched: Saved<BM>
+    const loaded = await this.getById(id, opt)
 
-    if (bm) {
-      patched = {
-        ...bm,
-        ...patch,
-      }
+    if (loaded) {
+      patched = { ...loaded, ...patch }
 
-      if (_deepJsonEquals(bm, patched)) {
+      if (_deepJsonEquals(loaded, patched)) {
         // Skipping the save operation, as data is the same
-        return bm
+        return patched
       }
     } else {
       patched = this.create({ ...patch, id }, opt)
@@ -871,29 +869,38 @@ export class CommonDao<
     return await this.save(patched, opt)
   }
 
-  async patchAsDBM(
-    id: ID,
-    patch: Partial<DBM>,
+  /**
+   * Same as patchById, but takes the whole object as input.
+   * This "whole object" is mutated with the patch and returned.
+   * Otherwise, similar behavior as patchById.
+   * It still loads the row from the DB.
+   */
+  async patch(
+    bm: Saved<BM>,
+    patch: Partial<BM>,
     opt: CommonDaoSaveBatchOptions<DBM> = {},
-  ): Promise<DBM> {
-    const dbm = await this.getByIdAsDBM(id, opt)
-    let patched: DBM
+  ): Promise<Saved<BM>> {
+    _assert(bm.id, 'patch argument object should have an id', {
+      bm,
+    })
 
-    if (dbm) {
-      patched = {
-        ...dbm,
-        ...patch,
-      }
+    const loaded = await this.getById(bm.id, opt)
 
-      if (_deepJsonEquals(dbm, patched)) {
+    if (loaded) {
+      Object.assign(loaded, patch)
+
+      if (_deepJsonEquals(loaded, bm)) {
         // Skipping the save operation, as data is the same
-        return dbm
+        return bm
       }
+
+      // Make `bm` exactly the same as `loaded`
+      _objectAssignExact(bm, loaded)
     } else {
-      patched = this.create({ ...patch, id } as Partial<BM>, opt) as any as DBM
+      Object.assign(bm, patch)
     }
 
-    return await this.saveAsDBM(patched, opt)
+    return await this.save(bm, opt)
   }
 
   async saveAsDBM(dbm: DBM, opt: CommonDaoSaveBatchOptions<DBM> = {}): Promise<DBM> {

package/src/pipeline/dbPipelineBackup.ts

@@ -8,6 +8,8 @@ import {
   pMap,
   _passthroughMapper,
   localTime,
+  UnixTimestampNumber,
+  StringMap,
 } from '@naturalcycles/js-lib'
 import {
   NDJsonStats,
@@ -65,10 +67,14 @@ export interface DBPipelineBackupOptions extends TransformLogProgressOptions {
 
   /**
    * If set - will do "incremental backup" (not full), only for entities that updated >= `sinceUpdated`
-   *
-   * @default undefined
    */
-  sinceUpdated?: number
+  sinceUpdated?: UnixTimestampNumber
+
+  /**
+   * Map for each table a `sinceUpdated` timestamp, or `undefined`.
+   * If set - will do "incremental backup" (not full), only for entities that updated >= `sinceUpdated` (on a per table basis)
+   */
+  sinceUpdatedPerTable?: StringMap<UnixTimestampNumber>
 
   /**
    * Directory path to store dumped files. Will create `${tableName}.ndjson` (or .ndjson.gz if gzip=true) files.
@@ -100,7 +106,7 @@ export interface DBPipelineBackupOptions extends TransformLogProgressOptions {
    * @default `{}`
    * Default mappers will be "passthroughMapper" (pass all data as-is).
    */
-  mapperPerTable?: Record<string, AsyncMapper>
+  mapperPerTable?: StringMap<AsyncMapper>
 
   /**
    * You can alter default `transformMapOptions` here.
@@ -143,7 +149,6 @@ export async function dbPipelineBackup(opt: DBPipelineBackupOptions): Promise<ND
     db,
     concurrency = 16,
     limit = 0,
-    sinceUpdated,
     outputDirPath,
     protectFromOverwrite = false,
     zlibOptions,
@@ -158,11 +163,7 @@ export async function dbPipelineBackup(opt: DBPipelineBackupOptions): Promise<ND
 
   let { tables } = opt
 
-  const sinceUpdatedStr = sinceUpdated ? ' since ' + grey(localTime(sinceUpdated).toPretty()) : ''
-
-  console.log(
-    `>> ${dimWhite('dbPipelineBackup')} started in ${grey(outputDirPath)}...${sinceUpdatedStr}`,
-  )
+  console.log(`>> ${dimWhite('dbPipelineBackup')} started in ${grey(outputDirPath)}...`)
 
   _ensureDirSync(outputDirPath)
 
@@ -175,6 +176,14 @@ export async function dbPipelineBackup(opt: DBPipelineBackupOptions): Promise<ND
   await pMap(
     tables,
     async table => {
+      const sinceUpdated = opt.sinceUpdatedPerTable?.[table] || opt.sinceUpdated
+
+      const sinceUpdatedStr = sinceUpdated
+        ? ' since ' + grey(localTime(sinceUpdated).toPretty())
+        : ''
+
+      console.log(`>> ${grey(table)}${sinceUpdatedStr}`)
+
       let q = DBQuery.create(table).limit(limit)
 
       if (sinceUpdated) {