@proteinjs/db 1.21.2 → 1.21.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proteinjs/db",
-  "version": "1.21.2",
+  "version": "1.21.4",
   "main": "./dist/generated/index.js",
   "types": "./dist/generated/index.d.ts",
   "exports": {
@@ -41,19 +41,19 @@
     "test": "jest"
   },
   "dependencies": {
-    "@proteinjs/db-query": "^1.4.2",
-    "@proteinjs/logger": "1.0.14",
-    "@proteinjs/reflection": "1.1.10",
-    "@proteinjs/serializer": "1.1.3",
-    "@proteinjs/server-api": "3.0.1",
-    "@proteinjs/service": "1.2.10",
-    "@proteinjs/user-auth": "1.1.8",
-    "@proteinjs/util": "1.5.0",
+    "@proteinjs/db-query": "^1.4.3",
+    "@proteinjs/logger": "^1.0.15",
+    "@proteinjs/reflection": "^1.1.11",
+    "@proteinjs/serializer": "^1.1.4",
+    "@proteinjs/server-api": "^3.0.2",
+    "@proteinjs/service": "^1.2.11",
+    "@proteinjs/user-auth": "^1.1.9",
+    "@proteinjs/util": "^1.6.0",
     "moment": "2.29.4",
     "uuid": "8.3.0"
   },
   "devDependencies": {
-    "@proteinjs/reflection-build": "1.4.2",
+    "@proteinjs/reflection-build": "^1.4.3",
     "@types/jest": "29.5.5",
     "@types/node": "14.0.27",
     "@types/uuid": "8.3.0",
@@ -66,5 +66,5 @@
     "ts-jest": "29.1.1",
     "typescript": "5.2.2"
   },
-  "gitHead": "bc9b351bda25b17783596a3dde363e86dae02f92"
+  "gitHead": "b437c941c73c3c0757fce492e1e918fc32457645"
 }

package/src/source/SourceRecordLoader.ts

@@ -4,6 +4,7 @@ import { getSourceRecordLoaders, SourceRecord, getSourceRecordTables } from './S
 import { Table } from '../Table';
 import { getDbAsSystem } from '../Db';
 import { SourceRecordRepo } from './SourceRecordRepo';
+import { RecordSerializer } from '../Record';
 
 type SourceRecordsMap = {
   [tableName: string]: { table: Table<any>; records: Omit<SourceRecord, 'created' | 'updated'>[]; recordIds: string[] };
@@ -18,6 +19,7 @@ export class SourceRecordLoader {
     for (const tableName in sourceRecordsMap) {
       let insertCount = 0;
       let updateCount = 0;
+      let unchangedCount = 0;
       let deleteCount = 0;
       const table = sourceRecordsMap[tableName].table;
       const sourceRecordIds = sourceRecordsMap[tableName].recordIds;
@@ -33,9 +35,14 @@ export class SourceRecordLoader {
       const sourceRecords = sourceRecordsMap[tableName].records;
       for (let sourceRecord of sourceRecords) {
         sourceRecord.isLoadedFromSource = true;
-        const count = await db.update(table, sourceRecord);
-        if (count > 0) {
-          updateCount += count;
+        const existingRecord = await db.get(table, { id: sourceRecord.id });
+        if (existingRecord) {
+          if (await this.hasChanges(table, sourceRecord, existingRecord)) {
+            await db.update(table, sourceRecord);
+            updateCount += 1;
+          } else {
+            unchangedCount += 1;
+          }
         } else {
           const dbSourceRecord = await db.insert(table, sourceRecord);
           sourceRecord = { ...sourceRecord, ...dbSourceRecord };
@@ -50,12 +57,106 @@ export class SourceRecordLoader {
         obj: {
           inserts: insertCount,
           updates: updateCount,
+          unchanged: unchangedCount,
           deletes: deleteCount,
         },
       });
     }
   }
 
+  /**
+   * Compare source record fields against the existing DB record to detect actual changes.
+   * Only fields present on the source record are compared (ignoring `created`, `updated`).
+   * Uses serialization to normalize values (e.g. Reference objects, Moment, JSON) before comparison.
+   *
+   * The comparison checks that every value in the source record exists with the same value
+   * in the existing DB record. Extra keys in the DB record are ignored — table watchers
+   * and hooks may enrich records with additional data after insert/update.
+   */
+  private async hasChanges(table: Table<any>, sourceRecord: any, existingRecord: any): Promise<boolean> {
+    const serializer = new RecordSerializer(table);
+    const serializedSource = await serializer.serialize(sourceRecord);
+    const serializedExisting = await serializer.serialize(existingRecord);
+    for (const columnName in serializedSource) {
+      if (columnName === 'created' || columnName === 'updated') {
+        continue;
+      }
+
+      const sourceValue = serializedSource[columnName];
+      const existingValue = serializedExisting[columnName];
+      if (this.findMismatchPath(sourceValue, existingValue, columnName)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Find the first point of divergence between source and existing values.
+   * Returns a description of the mismatch path, or null if they match.
+   * For objects, extra keys in `existing` are ignored — they may have been added by
+   * table watchers or hooks after the source record was loaded.
+   * For arrays, order and length must match exactly.
+   */
+  private findMismatchPath(source: any, existing: any, path: string): string | null {
+    if (source === existing) {
+      return null;
+    }
+
+    if (source == null || existing == null) {
+      if (source == existing) {
+        return null;
+      }
+      return `${path}: source=${JSON.stringify(source)}, existing=${JSON.stringify(existing)}`;
+    }
+
+    if (typeof source !== typeof existing) {
+      return `${path}: type mismatch: source=${typeof source}, existing=${typeof existing}`;
+    }
+
+    if (typeof source !== 'object') {
+      const sourceStr = typeof source === 'string' && source.length > 80 ? source.substring(0, 80) + '...' : source;
+      const existingStr =
+        typeof existing === 'string' && existing.length > 80 ? existing.substring(0, 80) + '...' : existing;
+      return `${path}: source=${JSON.stringify(sourceStr)}, existing=${JSON.stringify(existingStr)}`;
+    }
+
+    if (Array.isArray(source) !== Array.isArray(existing)) {
+      return `${path}: array mismatch: source isArray=${Array.isArray(source)}, existing isArray=${Array.isArray(existing)}`;
+    }
+
+    if (Array.isArray(source)) {
+      if (source.length !== existing.length) {
+        return `${path}: array length: source=${source.length}, existing=${existing.length}`;
+      }
+      for (let i = 0; i < source.length; i++) {
+        const result = this.findMismatchPath(source[i], existing[i], `${path}[${i}]`);
+        if (result) {
+          return result;
+        }
+      }
+      return null;
+    }
+
+    for (const key of Object.keys(source)) {
+      // Skip undefined values — they don't survive JSON serialization (JSON.stringify
+      // drops undefined), so the DB record won't have them.
+      if (source[key] === undefined) {
+        continue;
+      }
+      if (!(key in existing)) {
+        return `${path}.${key}: key missing in existing`;
+      }
+      const result = this.findMismatchPath(source[key], existing[key], `${path}.${key}`);
+      if (result) {
+        return result;
+      }
+    }
+
+    return null;
+  }
+
   private async getSourceRecordsMap() {
     const sourceRecordsMap: SourceRecordsMap = {};
     const sourceRecordTables = getSourceRecordTables();