@entity-access/entity-access 1.2.4 → 1.2.6

package/src/model/changes/ChangeEntry.ts

@@ -1,5 +1,5 @@
 import EntityAccessError from "../../common/EntityAccessError.js";
-import { IColumn } from "../../decorators/IColumn.js";
+import { IColumn, IEntityRelation } from "../../decorators/IColumn.js";
 import NameParser from "../../decorators/parser/NameParser.js";
 import EntityType from "../../entity-query/EntityType.js";
 import DateTime from "../../types/DateTime.js";
@@ -47,6 +47,7 @@ export default class ChangeEntry<T = any> implements IChanges {
         ce.pending = [];
         ce.dependents = new Set();
         ce.modified = new Map();
+        ce.order = 1;
         return ce;
     }
 
@@ -240,7 +241,7 @@ export default class ChangeEntry<T = any> implements IChanges {
         if (dbValues !== void 0) {
             const { entity, type } = this;
             for (const key in dbValues) {
-                if (Object.prototype.hasOwnProperty.call(dbValues, key)) {
+                if (Object.hasOwn(dbValues, key)) {
                     const element = dbValues[key];
                     entity[key] = element;
                 }
@@ -285,7 +286,7 @@ export default class ChangeEntry<T = any> implements IChanges {
         const { entity, original } = this;
         if (original) {
             for (const key in original) {
-                if (Object.prototype.hasOwnProperty.call(original, key)) {
+                if (Object.hasOwn(original, key)) {
                     const element = original[key];
                     entity[key] = element;
                 }
@@ -296,12 +297,9 @@ export default class ChangeEntry<T = any> implements IChanges {
     }
 
     detectDependencies() {
-        const { type: { relations }, entity } = this;
-        // for parent relations.. check if related key is set or not...
-        for (const iterator of relations) {
-            if (iterator.isInverseRelation) {
-                continue;
-            }
+        const { type: { fkRelations }, entity } = this;
+
+        for (const iterator of fkRelations) {
 
             // get related entry..
             const related = entity[iterator.name];
@@ -309,82 +307,108 @@ export default class ChangeEntry<T = any> implements IChanges {
                 continue;
             }
 
-            // if related has key defined.. set it...
-            // const rKey = iterator.relatedEntity.keys[0];
-
-            // lets set the prototype...
+            /**
+             * We need to set prototype,
+             *
+             * Reason:
+             * The prototype is not set when object is parsed from
+             * JSON and changeSet requires type
+             */
             const prototype = iterator.relatedTypeClass.prototype;
             if (Object.getPrototypeOf(related) !== prototype) {
                 Object.setPrototypeOf(related, prototype);
             }
-            const relatedChanges = this.changeSet.getEntry(related);
-
-            for (const { fkColumn, relatedKeyColumn } of iterator.fkMap) {
-                const keyValue = related[relatedKeyColumn.name];
-                if (keyValue === void 0 || keyValue === null) {
-
-                    if(relatedChanges.dependents.has(this)) {
-                        continue;
-                    }
-                    relatedChanges.dependents.add(this);
 
-                    this.order++;
+            const relatedChanges = this.changeSet.getEntry(related);
+            this.order += relatedChanges.order + 1;
 
-                    for (const d of this.dependents) {
-                        d.order += this.order + 1;
-                    }
+            relatedChanges.detectDependencies();
 
-                    if (!fkColumn.columnName) {
-                        throw new EntityAccessError(`Configuration error, fk not set for ${fkColumn.name}`);
-                    }
+            for (const { fkColumn, relatedKeyColumn } of iterator.fkMap) {
+                const key = related[relatedKeyColumn.name];
+                if (key === void 0 || key === null) {
                     relatedChanges.pending.push(() => {
-                        this.entity[fkColumn.name] = related[relatedKeyColumn.name];
+                        this.setValue(fkColumn, related[relatedKeyColumn.name]);
                     });
-                    if (this.status !== "inserted") {
-                        this.modified.set(iterator, { column: fkColumn, oldValue: void 0, newValue: void 0});
-                    }
-                }
-                continue;
-            }
-
-            if(!relatedChanges.dependents.has(this)) {
-                relatedChanges.dependents.add(this);
-                this.order += relatedChanges.order + 1;
-                for (const d of this.dependents) {
-                    d.order += this.order + 1;
+                } else {
+                    this.setValue(fkColumn, key);
                 }
             }
-            for (const { fkColumn, relatedKeyColumn } of iterator.fkMap) {
-                this.entity[fkColumn.name] = related[relatedKeyColumn.name];
-            }
-            // this.entity[iterator.fkColumn.name] = related[rKey.name];
         }
+
+        this.setupInverseProperties();
     }
 
     setupInverseProperties() {
         const deleted = this.status === "deleted";
-        for (const iterator of this.type.relations) {
-            if (!iterator.isInverseRelation) {
-                continue;
-            }
+        for (const iterator of this.type.inverseRelations) {
             const { relatedName } = iterator;
             const related = this.entity[iterator.name];
             if (related === void 0) {
                 continue;
             }
             if (Array.isArray(related)) {
+                if (deleted) {
+                    this.pending.push(() => {
+                        const index = related.indexOf(this.entity);
+                        if (index !== -1) {
+                            related.splice(index, 1);
+                        }
+                    });
+                    continue;
+                }
+
                 for (const r of related) {
-                    const existing = r[iterator.relatedName];
-                    if (existing !== this.entity) {
-                        r[iterator.relatedName] = this.entity;
-                    }
+                    this.setInversePropertyValue(r, iterator);
                 }
                 continue;
             }
-            related[relatedName] = this.entity;
             if (deleted) {
                 this.pending.push(() => delete related[relatedName]);
+                continue;
+            }
+            this.setInversePropertyValue(related, iterator);
+        }
+    }
+
+
+    private setInversePropertyValue(related: any, { relatedName , relatedRelation }: IEntityRelation) {
+        const { entity } = this;
+        const re = this.changeSet.getEntry(related);
+        re.order += this.order + 1;
+        if (related[relatedName] !== entity) {
+            related[relatedName] = entity;
+        }
+        if (this.status !== "inserted") {
+            for (const { fkColumn , relatedKeyColumn } of relatedRelation.fkMap) {
+                re.setValue(fkColumn, entity[relatedKeyColumn.name]);
             }
+            return;
         }
+        this.pending.push(() => {
+            for (const { fkColumn , relatedKeyColumn } of relatedRelation.fkMap) {
+                re.setValue(fkColumn, entity[relatedKeyColumn.name]);
+            }
+        });
     }
+
+    private setValue(column: IColumn, newValue) {
+        const oldValue = this.entity[column.name];
+        if (oldValue === newValue) {
+            return;
+        }
+        this.entity[column.name] = newValue;
+        this.modified.set(column, {
+            column,
+            newValue,
+            oldValue,
+        });
+        switch(this.status) {
+            case "detached":
+            case "unchanged":
+                this.status = "modified";
+                break;
+        }
+    }
+
 }

package/src/model/changes/ChangeSet.ts

@@ -37,23 +37,15 @@ export default class ChangeSet {
 
     *getChanges(max = 5): Generator<ChangeEntry, any, any> {
 
-        this.detectChanges();
+        const initialChanges = this.detectChanges();
 
-        // const pending = [] as ChangeEntry[];
-        // using d = this.addedEvent.listen((ce) => pending.push(ce.detail));
+        let copy = this.pending = [] as ChangeEntry[];
 
-
-        let copy = this.pending = [];
-
-        yield * [].concat(this.entries) as any;
+        yield *initialChanges;
 
         while(copy.length) {
             const next = this.pending = [];
-            for (const iterator of copy) {
-                iterator.setupInverseProperties();
-                iterator.detect();
-                yield iterator;
-            }
+            yield * this.detectChanges(copy);
             copy = next;
         }
 
@@ -125,17 +117,29 @@ export default class ChangeSet {
     /**
      * Detect changes will detect and sort the entries as they should be inserted.
      */
-    public detectChanges() {
+    public detectChanges(source = this.entries) {
 
-        for (const iterator of this.entries) {
+        const changes = [] as ChangeEntry[];
+
+        for (const iterator of source) {
             iterator.setupInverseProperties();
         }
 
-        for (const iterator of this.entries) {
+        for (const iterator of source) {
             iterator.detect();
+            switch(iterator.status) {
+                case "detached":
+                case "unchanged":
+                    continue;
+                default:
+                    changes.push(iterator);
+                    break;
+            }
         }
 
-        this.entries.sort((a, b) => a.order - b.order);
+        // this.entries.sort((a, b) => a.order - b.order);
+        changes.sort((a, b) => a.order - b.order);
+        return changes;
 
     }