@entity-access/entity-access 1.2.3 → 1.2.5

package/src/model/changes/ChangeEntry.ts

@@ -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;
     }
 
@@ -296,12 +297,12 @@ export default class ChangeEntry<T = any> implements IChanges {
     }
 
     detectDependencies() {
-        const { type: { relations }, entity } = this;
+        const { type: { fkRelations, inverseRelations }, entity } = this;
         // for parent relations.. check if related key is set or not...
-        for (const iterator of relations) {
-            if (iterator.isInverseRelation) {
-                continue;
-            }
+
+        let orderChanged = false;
+
+        for (const iterator of fkRelations) {
 
             // get related entry..
             const related = entity[iterator.name];
@@ -309,64 +310,88 @@ 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) {
+            this.order++;
+            orderChanged = true;
 
-                    if(relatedChanges.dependents.has(this)) {
-                        continue;
-                    }
-                    relatedChanges.dependents.add(this);
+            if (relatedChanges.status !== "inserted") {
+                for (const { fkColumn, relatedKeyColumn } of iterator.fkMap) {
+                    this.entity[fkColumn.name] = related[relatedKeyColumn.name];
+                }
+                continue;
+            }
 
-                    this.order++;
+            for (const { fkColumn, relatedKeyColumn } of iterator.fkMap) {
+                // const keyValue = related[relatedKeyColumn.name];
+                // if (keyValue === void 0 || keyValue === null) {
 
-                    for (const d of this.dependents) {
-                        d.order += this.order + 1;
-                    }
+                    // if(relatedChanges.dependents.has(this)) {
+                    //     continue;
+                    // }
+                    // relatedChanges.dependents.add(this);
 
-                    if (!fkColumn.columnName) {
-                        throw new EntityAccessError(`Configuration error, fk not set for ${fkColumn.name}`);
-                    }
+                    // for (const d of this.dependents) {
+                    //     d.order += this.order + 1;
+                    // }
+
+                    // if (!fkColumn.columnName) {
+                    //     throw new EntityAccessError(`Configuration error, fk not set for ${fkColumn.name}`);
+                    // }
                     relatedChanges.pending.push(() => {
                         this.entity[fkColumn.name] = related[relatedKeyColumn.name];
                     });
-                    if (this.status !== "inserted") {
-                        this.modified.set(iterator, { column: fkColumn, oldValue: void 0, newValue: void 0});
-                    }
-                }
-                continue;
+                    // 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;
-                }
-            }
-            for (const { fkColumn, relatedKeyColumn } of iterator.fkMap) {
-                this.entity[fkColumn.name] = related[relatedKeyColumn.name];
-            }
+
+
+            // 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;
+            //     }
+            // }
+            // for (const { fkColumn, relatedKeyColumn } of iterator.fkMap) {
+            //     this.entity[fkColumn.name] = related[relatedKeyColumn.name];
+            // }
             // this.entity[iterator.fkColumn.name] = related[rKey.name];
         }
+
+        if (!orderChanged) {
+            return;
+        }
+
+        for (const element of inverseRelations) {
+            const inverseRelation = this[element.name];
+            if (!inverseRelation) {
+                continue;
+            }
+            // inversely related item can never be an array
+            this.changeSet.getEntry(inverseRelation).order++;
+        }
     }
 
     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) {
@@ -374,14 +399,20 @@ export default class ChangeEntry<T = any> implements IChanges {
             }
             if (Array.isArray(related)) {
                 for (const r of related) {
-                    const existing = r[iterator.relatedName];
+                    const existing = r[relatedName];
                     if (existing !== this.entity) {
                         r[iterator.relatedName] = this.entity;
+                        // need to update order...
+                        this.changeSet.getEntry(r).order++;
                     }
                 }
                 continue;
             }
-            related[relatedName] = this.entity;
+            if (related[relatedName] !== this.entity) {
+                related[relatedName] = this.entity;
+                // need to update order...
+                this.changeSet.getEntry(related).order++;
+            }
             if (deleted) {
                 this.pending.push(() => delete related[relatedName]);
             }

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;
 
     }