@entity-access/entity-access 1.2.5 → 1.2.9

package/src/di/di.ts

@@ -163,7 +163,7 @@ export class ServiceProvider implements IDisposable {
         const keys = type.prototype[injectServiceKeysSymbol];
         if (keys) {
             for (const key in keys) {
-                if (Object.prototype.hasOwnProperty.call(keys, key)) {
+                if (Object.hasOwn(keys, key)) {
                     const element = keys[key];
                     instance[key] ??= this.resolve(element);
                 }

package/src/drivers/base/BaseDriver.ts

@@ -417,7 +417,7 @@ export abstract class BaseDriver {
     createSelectWithKeysExpression(type: EntityType, check: any, returnFields: Expression[] ) {
         let where = null as Expression;
         for (const key in check) {
-            if (Object.prototype.hasOwnProperty.call(check, key)) {
+            if (Object.hasOwn(check, key)) {
                 const element = check[key];
                 const column = type.getField(key).quotedColumnNameExp;
                 const condition = Expression.equal(column, Expression.constant(element));
@@ -448,7 +448,7 @@ export abstract class BaseDriver {
         if (mode === "delete") {
             let where = null as Expression;
             for (const key in test) {
-                if (Object.prototype.hasOwnProperty.call(test, key)) {
+                if (Object.hasOwn(test, key)) {
                     const element = test[key];
                     const { quotedColumnNameExp } = type.getField(key);
                     const compare = Expression.equal(quotedColumnNameExp, Expression.constant(element));
@@ -520,7 +520,7 @@ export abstract class BaseDriver {
 
         if(test) {
             for (const key in test) {
-                if (Object.prototype.hasOwnProperty.call(test, key)) {
+                if (Object.hasOwn(test, key)) {
                     const element = test[key];
                     const { quotedColumnNameExp } = type.getField(key);
                     keys.push(Expression.equal(quotedColumnNameExp, Expression.constant(element)));

package/src/model/EntityContext.ts

@@ -195,7 +195,7 @@ export default class EntityContext {
                     await events.beforeInsert(iterator.entity, iterator);
                     verificationSession?.queueVerification(iterator, events);
                     pending.push({ status: iterator.status, change: iterator, events });
-                    iterator.setupInverseProperties();
+                    iterator.detectDependencies();
                     copy.push(iterator);
                     continue;
                 case "modified":
@@ -216,23 +216,22 @@ export default class EntityContext {
 
         await verificationSession?.verifyAsync();
 
+        copy.sort((a, b) => a.order - b.order);
+
         await this.saveChangesInternalWithoutEvents(options, copy);
 
-        if (pending.length > 0) {
-
-            for (const { status, change, change: { entity}, events } of pending) {
-                switch(status) {
-                    case "inserted":
-                        await events.afterInsert(entity, change);
-                        continue;
-                    case "modified":
-                        await events.afterUpdate(entity, change);
-                        change.clearUpdated();
-                        continue;
-                    case "deleted":
-                        await events.afterDelete(entity, change);
-                        continue;
-                }
+        for (const { status, change, change: { entity}, events } of pending) {
+            switch(status) {
+                case "inserted":
+                    await events.afterInsert(entity, change);
+                    continue;
+                case "modified":
+                    await events.afterUpdate(entity, change);
+                    change.clearUpdated();
+                    continue;
+                case "deleted":
+                    await events.afterDelete(entity, change);
+                    continue;
             }
         }
 

package/src/model/EntitySource.ts

@@ -16,7 +16,7 @@ const removeUndefined = (obj) => {
     }
     const r = {};
     for (const key in obj) {
-        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+        if (Object.hasOwn(obj, key)) {
             const element = obj[key];
             if (element === void 0) {
                 continue;
@@ -77,7 +77,7 @@ export class EntityStatements<T = any> {
         const result = r.rows[0];
         if (result) {
             for (const key in result) {
-                if (Object.prototype.hasOwnProperty.call(result, key)) {
+                if (Object.hasOwn(result, key)) {
                     const element = result[key];
                     entity[key] = element;
                 }
@@ -105,7 +105,7 @@ export class EntityStatements<T = any> {
         const result = r.rows[0];
         if (result) {
             for (const key in result) {
-                if (Object.prototype.hasOwnProperty.call(result, key)) {
+                if (Object.hasOwn(result, key)) {
                     const element = result[key];
                     entity[key] = element;
                 }
@@ -133,7 +133,7 @@ export class EntityStatements<T = any> {
         const result = r.rows[0];
         if (result) {
             for (const key in result) {
-                if (Object.prototype.hasOwnProperty.call(result, key)) {
+                if (Object.hasOwn(result, key)) {
                     const element = result[key];
                     entity[key] = element;
                 }
@@ -189,7 +189,7 @@ export class EntityStatements<T = any> {
                 if (existing) {
                     existing = updateAfterSelect(existing);
                     for (const key in existing) {
-                        if (Object.prototype.hasOwnProperty.call(existing, key)) {
+                        if (Object.hasOwn(existing as any, key)) {
                             entity[key] = existing[key];
                         }
                     }
@@ -300,7 +300,7 @@ export class EntitySource<T = any> {
             if (er.rows?.[0]) {
                 const fr = er.rows[0];
                 for (const key in fr) {
-                    if (Object.prototype.hasOwnProperty.call(fr, key)) {
+                    if (Object.hasOwn(fr, key)) {
                         const element = fr[key];
                         const name = this.model.getColumn(key).name;
                         returnEntity[name] = element;
@@ -314,7 +314,7 @@ export class EntitySource<T = any> {
                     const original = { ... returnEntity, ... changes };
                     const updates = updateAfterSelect(original);
                     for (const key in updates) {
-                        if (Object.prototype.hasOwnProperty.call(updates, key)) {
+                        if (Object.hasOwn(updates as any, key)) {
                             const element = updates[key];
                             changes[key] = element;
                         }
@@ -341,7 +341,7 @@ export class EntitySource<T = any> {
             if(r.rows?.length) {
                 const first = r.rows[0];
                 for (const key in first) {
-                    if (Object.prototype.hasOwnProperty.call(first, key)) {
+                    if (Object.hasOwn(first, key)) {
                         const element = first[key];
                         const name = this.model.getColumn(key).name;
                         returnEntity[name] ??= element;

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";
@@ -241,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;
                 }
@@ -286,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;
                 }
@@ -297,10 +297,7 @@ export default class ChangeEntry<T = any> implements IChanges {
     }
 
     detectDependencies() {
-        const { type: { fkRelations, inverseRelations }, entity } = this;
-        // for parent relations.. check if related key is set or not...
-
-        let orderChanged = false;
+        const { type: { fkRelations }, entity } = this;
 
         for (const iterator of fkRelations) {
 
@@ -323,70 +320,23 @@ export default class ChangeEntry<T = any> implements IChanges {
             }
 
             const relatedChanges = this.changeSet.getEntry(related);
+            this.order += relatedChanges.order + 1;
 
-            this.order++;
-            orderChanged = true;
-
-            if (relatedChanges.status !== "inserted") {
-                for (const { fkColumn, relatedKeyColumn } of iterator.fkMap) {
-                    this.entity[fkColumn.name] = related[relatedKeyColumn.name];
-                }
-                continue;
-            }
+            relatedChanges.detectDependencies();
 
             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);
-
-                    // 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}`);
-                    // }
+                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;
+                } else {
+                    this.setValue(fkColumn, key);
+                }
             }
-
-
-
-            // 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++;
-        }
+        this.setupInverseProperties();
     }
 
     setupInverseProperties() {
@@ -398,24 +348,67 @@ export default class ChangeEntry<T = any> implements IChanges {
                 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[relatedName];
-                    if (existing !== this.entity) {
-                        r[iterator.relatedName] = this.entity;
-                        // need to update order...
-                        this.changeSet.getEntry(r).order++;
-                    }
+                    this.setInversePropertyValue(r, iterator);
                 }
                 continue;
             }
-            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]);
+                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/events/FilteredExpression.ts

@@ -6,7 +6,6 @@
 
 export const filteredSymbol = Symbol("filtered");
 
-const hasOwnProperty = Object.prototype.hasOwnProperty;
 
 export const FilteredExpression = {
     isFiltered(fx): boolean {
@@ -21,7 +20,7 @@ export const FilteredExpression = {
         }
         fx[filteredSymbol] = true;
         for (const key in fx) {
-            if (hasOwnProperty.call(fx, key)) {
+            if (Object.hasOwn(fx, key)) {
                 const element = fx[key];
                 FilteredExpression.markAsFiltered(element);
             }

package/src/query/ast/Expressions.ts

@@ -134,7 +134,7 @@ export abstract class Expression {
         const r = {} as any;
         Object.setPrototypeOf(r, Object.getPrototypeOf(expression));
         for (const key in expression) {
-            if (Object.prototype.hasOwnProperty.call(expression, key)) {
+            if (Object.hasOwn(expression, key)) {
                 const element = expression[key];
                 if(Array.isArray(element)) {
                     r[key] = element.map((x) => this.clone(x));
@@ -149,7 +149,7 @@ export abstract class Expression {
     private static shallowCopy(expression, constants: Expression[]) {
         const copy = {} as any;
         for (const key in expression) {
-            if (Object.prototype.hasOwnProperty.call(expression, key)) {
+            if (Object.hasOwn(expression, key)) {
                 const element = expression[key];
                 if (key === "type" || key === "is") {
                     continue;

package/src/query/ast/ReplaceParameter.ts

@@ -27,7 +27,7 @@ export default class ReplaceParameter {
         }
         const treeCopy = {} as any;
         for (const key in tree) {
-            if (Object.prototype.hasOwnProperty.call(tree, key)) {
+            if (Object.hasOwn(tree as any, key)) {
                 const element = tree[key];
                 if (element && typeof element === "object") {
                     treeCopy[key] = this.replace(element, from, to);

package/tsconfig.json

@@ -9,6 +9,7 @@
         "importHelpers": true,
         "outDir": "dist",
         "rootDir": "./src",
+        "tsBuildInfoFile": "./dist/.tsbuildinfo",
         "strict": false,
         "skipDefaultLibCheck": true,
         "skipLibCheck": true,