breeze-client 2.2.0 → 2.2.1-cjs

package/esm2015/src/default-property-interceptor.js

@@ -0,0 +1,460 @@
+import { core } from './core';
+import { EntityKey } from './entity-key';
+import { EntityAspect } from './entity-aspect';
+import { EntityState } from './entity-state';
+import { EntityAction } from './entity-action';
+import { EntityQuery } from './entity-query';
+/** @hidden @internal */
+export function defaultPropertyInterceptor(property, newValue, rawAccessorFn) {
+    // 'this' is the entity itself in this context.
+    if (newValue === undefined)
+        newValue = null; // remove? to allow assignment to undefined in Babel constructors?
+    let oldValue = rawAccessorFn();
+    let dataType = property.dataType;
+    if (dataType && dataType.parse) {
+        // attempts to coerce a value to the correct type - if this fails return the value unchanged
+        if (Array.isArray(newValue) && !property.isScalar) {
+            newValue = newValue.map(function (nv) {
+                return dataType.parse(nv, typeof nv);
+            });
+        }
+        else {
+            newValue = dataType.parse(newValue, typeof newValue);
+        }
+    }
+    // exit if no change - extra cruft is because dateTimes don't compare cleanly.
+    if (newValue === oldValue || (newValue === null && oldValue === undefined) ||
+        (dataType && dataType.normalize && newValue && oldValue && dataType.normalize(newValue) === dataType.normalize(oldValue))) {
+        return;
+    }
+    // CANNOT DO NEXT LINE because it has the possibility of creating a new property
+    // 'entityAspect' on 'this'.  - Not permitted by IE inside of a defined property on a prototype.
+    // let entityAspect = new EntityAspect(this);
+    let propertyName;
+    let entityAspect = this.entityAspect;
+    if (entityAspect) {
+        propertyName = property.name;
+    }
+    else {
+        let localAspect = this.complexAspect;
+        if (localAspect) {
+            entityAspect = localAspect.getEntityAspect();
+            propertyName = localAspect.getPropertyPath(property.name);
+        }
+        else {
+            // does not yet have an EntityAspect so just set the prop
+            rawAccessorFn(newValue);
+            return;
+        }
+    }
+    // Note that we need to handle multiple properties in process, not just one in order to avoid recursion.
+    // ( except in the case of null propagation with fks where null -> 0 in some cases.)
+    // (this may not be needed because of the newValue === oldValue test above)
+    let inProcess = entityAspect._inProcess = entityAspect._inProcess || [];
+    // check for recursion
+    if (inProcess.indexOf(property) >= 0)
+        return;
+    inProcess.push(property);
+    try {
+        let context = {
+            parent: this,
+            property: property,
+            newValue: newValue,
+            oldValue: oldValue,
+            propertyName: propertyName,
+            entityAspect: entityAspect
+        };
+        if (property.isComplexProperty) {
+            setDpValueComplex(context, rawAccessorFn);
+        }
+        else if (property.isDataProperty) {
+            setDpValueSimple(context, rawAccessorFn);
+        }
+        else {
+            setNpValue(context, rawAccessorFn);
+        }
+        postChangeEvents(context);
+    }
+    finally {
+        inProcess.pop();
+    }
+}
+function setDpValueSimple(context, rawAccessorFn) {
+    let parent = context.parent;
+    let property = context.property;
+    let entityAspect = context.entityAspect;
+    let oldValue = context.oldValue;
+    let newValue = context.newValue;
+    let entityManager = entityAspect.entityManager;
+    if (!property.isScalar) {
+        throw new Error("Nonscalar data properties are readonly - items may be added or removed but the collection may not be changed.");
+    }
+    // store an original value for this property if not already set
+    if (entityAspect.entityState.isUnchangedOrModified()) {
+        let propName = property.name;
+        // localAspect is not the same as entityAspect for complex props
+        let localAspect = EntityAspect.isEntity(parent) ? parent.entityAspect : parent.complexAspect;
+        if (localAspect.originalValues[propName] === undefined) {
+            // otherwise this entry will be skipped during serialization
+            localAspect.originalValues[propName] = oldValue !== undefined ? oldValue : property.defaultValue;
+        }
+    }
+    // if we are changing the key update our internal entityGroup indexes.
+    if (property.isPartOfKey && entityManager && !entityManager.isLoading) {
+        // 'entityType' on the next line be null for complex properties but it will only be ref'd within this
+        // fn when the property is part of the key
+        let entityType = parent.entityType;
+        let keyProps = entityType.keyProperties;
+        let values = keyProps.map(function (p) {
+            if (p === property) {
+                return newValue;
+            }
+            else {
+                return parent.getProperty(p.name);
+            }
+        });
+        let newKey = new EntityKey(entityType, values);
+        if (entityManager.getEntityByKey(newKey)) {
+            throw new Error("An entity with this key is already in the cache: " + newKey.toString());
+        }
+        let oldKey = parent.entityAspect.getKey();
+        let eg = entityManager._findEntityGroup(entityType);
+        eg._replaceKey(oldKey, newKey);
+    }
+    // process related updates ( the inverse relationship) first so that collection dups check works properly.
+    // update inverse relationship
+    let relatedNavProp = property.relatedNavigationProperty;
+    if (relatedNavProp && entityManager) {
+        // Example: bidirectional fkDataProperty: 1->n: order -> orderDetails
+        // orderDetail.orderId <- newOrderId || null
+        //    ==> orderDetail.order = lookupOrder(newOrderId)
+        //    ==> (see set navProp above)
+        //       and
+        // Example: bidirectional fkDataProperty: 1->1: order -> internationalOrder
+        // internationalOrder.orderId <- newOrderId || null
+        //    ==> internationalOrder.order = lookupOrder(newOrderId)
+        //    ==> (see set navProp above)
+        if (newValue != null) {
+            let relatedEntity;
+            let key;
+            if (relatedNavProp.invForeignKeyNames.length) {
+                // property is related by field which is not the PK
+                const query = new EntityQuery(relatedNavProp.entityType.defaultResourceName).where(relatedNavProp.invForeignKeyNames[0], 'eq', newValue);
+                const qresult = entityManager.executeQueryLocally(query);
+                if (qresult.length === 1) {
+                    relatedEntity = qresult[0];
+                }
+            }
+            else {
+                // property is related by the PK
+                key = new EntityKey(relatedNavProp.entityType, [newValue]);
+                relatedEntity = entityManager.getEntityByKey(key);
+            }
+            if (relatedEntity) {
+                parent.setProperty(relatedNavProp.name, relatedEntity);
+            }
+            else {
+                // it may not have been fetched yet in which case we want to add it as an unattachedChild.
+                if (key) {
+                    // TODO currently _linkRelatedentities only works with PK relations, so we only add those.
+                    entityManager._unattachedChildrenMap.addChild(key, relatedNavProp, parent);
+                }
+                parent.setProperty(relatedNavProp.name, null);
+            }
+        }
+        else {
+            parent.setProperty(relatedNavProp.name, null);
+        }
+    }
+    else if (property.inverseNavigationProperty && entityManager && !entityManager._inKeyFixup) {
+        // Example: unidirectional fkDataProperty: 1->n: region -> territories
+        // territory.regionId <- newRegionId
+        //    ==> lookupRegion(newRegionId).territories.push(territory)
+        //                and
+        // Example: unidirectional fkDataProperty: 1->1: order -> internationalOrder
+        // internationalOrder.orderId <- newOrderId
+        //    ==> lookupOrder(newOrderId).internationalOrder = internationalOrder
+        //                and
+        // Example: unidirectional fkDataProperty: 1->n: region -> territories
+        // territory.regionId <- null
+        //    ==> lookupRegion(territory.oldRegionId).territories.remove(oldTerritory);
+        //                and
+        // Example: unidirectional fkDataProperty: 1->1: order -> internationalOrder
+        // internationalOrder.orderId <- null
+        //    ==> lookupOrder(internationalOrder.oldOrderId).internationalOrder = null;
+        let invNavProp = property.inverseNavigationProperty;
+        if (oldValue != null) {
+            let key = new EntityKey(invNavProp.parentType, [oldValue]);
+            let relatedEntity = entityManager.getEntityByKey(key);
+            if (relatedEntity) {
+                if (invNavProp.isScalar) {
+                    relatedEntity.setProperty(invNavProp.name, null);
+                }
+                else {
+                    // remove 'this' from old related nav prop
+                    let relatedArray = relatedEntity.getProperty(invNavProp.name);
+                    // arr.splice(arr.indexOf(value_to_remove), 1);
+                    relatedArray.splice(relatedArray.indexOf(parent), 1);
+                }
+            }
+        }
+        if (newValue != null) {
+            let key = new EntityKey(invNavProp.parentType, [newValue]);
+            let relatedEntity = entityManager.getEntityByKey(key);
+            if (relatedEntity) {
+                if (invNavProp.isScalar) {
+                    relatedEntity.setProperty(invNavProp.name, parent);
+                }
+                else {
+                    relatedEntity.getProperty(invNavProp.name).push(parent);
+                }
+            }
+            else {
+                // it may not have been fetched yet in which case we want to add it as an unattachedChild.
+                entityManager._unattachedChildrenMap.addChild(key, invNavProp, parent);
+            }
+        }
+    }
+    rawAccessorFn(newValue);
+    updateStateAndValidate(context);
+    // if (property.isPartOfKey && (!this.complexAspect)) {
+    if (property.isPartOfKey) {
+        // propogate pk change to all related entities;
+        let entityType = parent.entityType;
+        let propertyIx = entityType.keyProperties.indexOf(property);
+        // this part handles order.orderId => orderDetail.orderId
+        // but won't handle product.productId => orderDetail.productId because product
+        // doesn't have an orderDetails property.
+        entityType.navigationProperties.forEach(function (np) {
+            let inverseNp = np.inverse;
+            let fkNames = inverseNp ? inverseNp.foreignKeyNames : np.invForeignKeyNames;
+            if (fkNames.length === 0)
+                return;
+            let npValue = parent.getProperty(np.name);
+            if (!npValue)
+                return;
+            let fkName = fkNames[propertyIx];
+            if (np.isScalar) {
+                npValue.setProperty(fkName, newValue);
+            }
+            else {
+                npValue.slice(0).forEach(function (iv) {
+                    iv.setProperty(fkName, newValue);
+                });
+            }
+        });
+        // this handles unidirectional problems not covered above.
+        if (entityManager) {
+            let inverseForeignKeyProperties = entityType.inverseForeignKeyProperties;
+            let baseEntityType = entityType.baseEntityType;
+            while (baseEntityType) {
+                inverseForeignKeyProperties = inverseForeignKeyProperties.concat(baseEntityType.inverseForeignKeyProperties);
+                baseEntityType = baseEntityType.baseEntityType;
+            }
+            inverseForeignKeyProperties.forEach((invFkProp) => {
+                if (invFkProp.relatedNavigationProperty.inverse == null) {
+                    // this next step may be slow - it iterates over all of the entities in a group;
+                    // hopefully it doesn't happen often.
+                    entityManager._updateFkVal(invFkProp, oldValue, newValue);
+                }
+            });
+        }
+        // insure that cached key is updated.
+        entityAspect.getKey(true);
+    }
+}
+function setDpValueComplex(context, rawAccessorFn) {
+    let property = context.property;
+    let oldValue = context.oldValue;
+    let newValue = context.newValue;
+    // To get here it must be a ComplexProperty
+    // 'dataType' will be a complexType
+    let dataType = property.dataType;
+    if (property.isScalar) {
+        if (!newValue) {
+            throw new Error(core.formatString("You cannot set the '%1' property to null because its datatype is the ComplexType: '%2'", property.name, property.dataType.name));
+        }
+        if (!oldValue) {
+            let ctor = dataType.getCtor();
+            oldValue = new ctor();
+            rawAccessorFn(oldValue);
+        }
+        dataType.dataProperties.forEach(function (dp) {
+            let pn = dp.name;
+            let nv = newValue.getProperty(pn);
+            oldValue.setProperty(pn, nv);
+        });
+    }
+    else {
+        throw new Error(core.formatString("You cannot set the non-scalar complex property: '%1' on the type: '%2'." +
+            "Instead get the property and use array functions like 'push' or 'splice' to change its contents.", property.name, property.parentType.name));
+    }
+}
+function setNpValue(context, rawAccessorFn) {
+    let parent = context.parent;
+    let property = context.property;
+    let entityAspect = context.entityAspect;
+    let oldValue = context.oldValue;
+    let newValue = context.newValue;
+    if (!property.isScalar) {
+        throw new Error("Nonscalar navigation properties are readonly - entities can be added or removed but the collection may not be changed.");
+    }
+    let entityManager = entityAspect.entityManager;
+    let inverseProp = property.inverse;
+    // manage attachment -
+    if (newValue != null) {
+        if (!newValue.entityAspect) {
+            return;
+        }
+        let newAspect = newValue.entityAspect;
+        if (entityManager) {
+            if (newAspect.entityState.isDetached()) {
+                if (!entityManager.isLoading) {
+                    entityManager.attachEntity(newValue, EntityState.Added);
+                }
+            }
+            else {
+                if (newAspect.entityManager !== entityManager) {
+                    throw new Error("An Entity cannot be attached to an entity in another EntityManager. One of the two entities must be detached first.");
+                }
+            }
+        }
+        else {
+            if (newAspect && newAspect.entityManager) {
+                entityManager = newAspect.entityManager;
+                if (!entityManager.isLoading) {
+                    entityManager.attachEntity(entityAspect.entity, EntityState.Added);
+                }
+            }
+        }
+    }
+    // process related updates ( the inverse relationship) first so that collection dups check works properly.
+    // update inverse relationship
+    if (inverseProp) {
+        ///
+        if (inverseProp.isScalar) {
+            // Example: bidirectional navProperty: 1->1: order -> internationalOrder
+            // order.internationalOrder <- internationalOrder || null
+            //    ==> (oldInternationalOrder.order = null)
+            //    ==> internationalOrder.order = order
+            if (oldValue != null) {
+                // TODO: null -> NullEntity later
+                oldValue.setProperty(inverseProp.name, null);
+            }
+            if (newValue != null) {
+                newValue.setProperty(inverseProp.name, parent);
+            }
+        }
+        else {
+            // Example: bidirectional navProperty: 1->n: order -> orderDetails
+            // orderDetail.order <- newOrder || null
+            //    ==> (oldOrder).orderDetails.remove(orderDetail)
+            //    ==> order.orderDetails.push(newOrder)
+            if (oldValue != null) {
+                let oldSiblings = oldValue.getProperty(inverseProp.name);
+                let ix = oldSiblings.indexOf(parent);
+                if (ix !== -1) {
+                    oldSiblings.splice(ix, 1);
+                }
+            }
+            if (newValue != null) {
+                let siblings = newValue.getProperty(inverseProp.name);
+                // recursion check if already in the collection is performed by the relationArray
+                siblings.push(parent);
+            }
+        }
+    }
+    else if (property.invForeignKeyNames && entityManager && !entityManager._inKeyFixup) {
+        let invForeignKeyNames = property.invForeignKeyNames;
+        if (newValue != null) {
+            // Example: unidirectional navProperty: 1->1: order -> internationalOrder
+            // order.InternationalOrder <- internationalOrder
+            //    ==> internationalOrder.orderId = orderId
+            //      and
+            // Example: unidirectional navProperty: 1->n: order -> orderDetails
+            // orderDetail.order <-xxx newOrder
+            //    ==> CAN'T HAPPEN because if unidirectional because orderDetail will not have an order prop
+            let pkValues = parent.entityAspect.getKey().values;
+            invForeignKeyNames.forEach((fkName, i) => {
+                newValue.setProperty(fkName, pkValues[i]);
+            });
+        }
+        else {
+            // Example: unidirectional navProperty: 1->1: order -> internationalOrder
+            // order.internationalOrder <- null
+            //    ==> (old internationalOrder).orderId = null
+            //        and
+            // Example: unidirectional navProperty: 1->n: order -> orderDetails
+            // orderDetail.order <-xxx newOrder
+            //    ==> CAN'T HAPPEN because if unidirectional because orderDetail will not have an order prop
+            if (oldValue != null) {
+                invForeignKeyNames.forEach((fkName) => {
+                    let fkProp = oldValue.entityType.getProperty(fkName);
+                    if (!fkProp.isPartOfKey) {
+                        // don't update with null if fk is part of the key
+                        oldValue.setProperty(fkName, null);
+                    }
+                });
+            }
+        }
+    }
+    rawAccessorFn(newValue);
+    updateStateAndValidate(context);
+    // update fk data property - this can only occur if this navProperty has
+    // a corresponding fk on this entity.
+    if (property.relatedDataProperties) {
+        let entityState = entityAspect.entityState;
+        // if either side of nav prop is detached don't clear fks. Note: oldValue in next line cannot be null so no check is needed.
+        if (newValue == null && (entityState.isDetached() || oldValue.entityAspect.entityState.isDetached()))
+            return;
+        if (entityState.isDeleted())
+            return;
+        // we may have inverse props indicating the related prop on the other entity, if it is not the other entity's PK
+        let inverseKeyProps = property.invForeignKeyNames;
+        if (!(inverseKeyProps && inverseKeyProps.length)) {
+            // otherwise, this prop is related to the other entity's PK
+            inverseKeyProps = property.entityType.keyProperties.map(k => k.name);
+        }
+        inverseKeyProps.forEach(function (keyProp, i) {
+            let relatedDataProp = property.relatedDataProperties[i];
+            // Do not trash related property if it is part of that entity's key
+            if (newValue || !relatedDataProp.isPartOfKey) {
+                let relatedValue = newValue ? newValue.getProperty(keyProp) : relatedDataProp.defaultValue;
+                parent.setProperty(relatedDataProp.name, relatedValue);
+            }
+        });
+    }
+}
+function postChangeEvents(context) {
+    let entityAspect = context.entityAspect;
+    let entityManager = entityAspect.entityManager;
+    let entity = entityAspect.entity;
+    let propChangedArgs = { entity: entity, parent: context.parent, property: context.property, propertyName: context.propertyName, oldValue: context.oldValue, newValue: context.newValue };
+    if (entityManager) {
+        // propertyChanged will be fired during loading but we only want to fire it once per entity, not once per property.
+        // so propertyChanged is fired in the entityManager mergeEntity method if not fired here.
+        if ((!entityManager.isLoading) && (!entityManager.isRejectingChanges)) {
+            entityAspect.propertyChanged.publish(propChangedArgs);
+            // don't fire entityChanged event if propertyChanged is suppressed.
+            entityManager.entityChanged.publish({ entityAction: EntityAction.PropertyChange, entity: entity, args: propChangedArgs });
+        }
+    }
+    else {
+        entityAspect.propertyChanged.publish(propChangedArgs);
+    }
+}
+function updateStateAndValidate(context) {
+    let entityAspect = context.entityAspect;
+    let entityManager = entityAspect.entityManager;
+    if (entityManager == null || entityManager.isLoading)
+        return;
+    let property = context.property;
+    if (entityAspect.entityState.isUnchanged() && !property.isUnmapped) {
+        entityAspect.setModified();
+    }
+    if (entityManager.validationOptions.validateOnPropertyChange) {
+        // entityAspect.entity is NOT the same as parent in the code below. It's use is deliberate.
+        entityAspect._validateProperty(context.newValue, { entity: entityAspect.entity, property: property, propertyName: context.propertyName, oldValue: context.oldValue });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"default-property-interceptor.js","sourceRoot":"ng://breeze-client/","sources":["src/default-property-interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["import { core } from './core';\r\nimport { ComplexType, DataProperty, NavigationProperty, EntityProperty } from './entity-metadata';\r\nimport { EntityKey } from './entity-key';\r\nimport { EntityAspect, ComplexAspect, Entity, StructuralObject } from './entity-aspect';\r\nimport { EntityState } from './entity-state';\r\nimport { EntityAction } from './entity-action';\r\nimport { EntityQuery } from './entity-query';\r\n\r\n/** @hidden @internal */\r\nexport function defaultPropertyInterceptor(this: StructuralObject, property: EntityProperty, newValue: any, rawAccessorFn: Function) {\r\n  // 'this' is the entity itself in this context.\r\n\r\n  if (newValue === undefined) newValue = null; // remove? to allow assignment to undefined in Babel constructors?\r\n  let oldValue = rawAccessorFn();\r\n\r\n  let dataType = (property as any).dataType;\r\n  if (dataType && dataType.parse) {\r\n    // attempts to coerce a value to the correct type - if this fails return the value unchanged\r\n    if (Array.isArray(newValue) && !property.isScalar) {\r\n      newValue = newValue.map(function (nv) {\r\n        return dataType.parse(nv, typeof nv);\r\n      });\r\n    } else {\r\n      newValue = dataType.parse(newValue, typeof newValue);\r\n    }\r\n  }\r\n\r\n  // exit if no change - extra cruft is because dateTimes don't compare cleanly.\r\n  if (newValue === oldValue || (newValue === null && oldValue === undefined) || \r\n    (dataType && dataType.normalize && newValue && oldValue && dataType.normalize(newValue) === dataType.normalize(oldValue))) {\r\n    return;\r\n  }\r\n\r\n  // CANNOT DO NEXT LINE because it has the possibility of creating a new property\r\n  // 'entityAspect' on 'this'.  - Not permitted by IE inside of a defined property on a prototype.\r\n  // let entityAspect = new EntityAspect(this);\r\n\r\n  let propertyName: string;\r\n  let entityAspect = (this as any).entityAspect as EntityAspect;\r\n  if (entityAspect) {\r\n    propertyName = property.name;\r\n  } else {\r\n    let localAspect = (this as any).complexAspect as ComplexAspect;\r\n    if (localAspect) {\r\n      entityAspect = localAspect.getEntityAspect();\r\n      propertyName = localAspect.getPropertyPath(property.name);\r\n    } else {\r\n      // does not yet have an EntityAspect so just set the prop\r\n      rawAccessorFn(newValue);\r\n      return;\r\n    }\r\n  }\r\n\r\n  // Note that we need to handle multiple properties in process, not just one in order to avoid recursion.\r\n  // ( except in the case of null propagation with fks where null -> 0 in some cases.)\r\n  // (this may not be needed because of the newValue === oldValue test above)\r\n  let inProcess = entityAspect._inProcess = entityAspect._inProcess || [];\r\n  // check for recursion\r\n  if (inProcess.indexOf(property) >= 0) return;\r\n  inProcess.push(property);\r\n\r\n  try {\r\n\r\n    let context: IContext = {\r\n      parent: this,\r\n      property: property,\r\n      newValue: newValue,\r\n      oldValue: oldValue,\r\n      propertyName: propertyName,\r\n      entityAspect: entityAspect\r\n    };\r\n\r\n    if ((property as any).isComplexProperty) {\r\n      setDpValueComplex(context, rawAccessorFn);\r\n    } else if (property.isDataProperty) {\r\n      setDpValueSimple(context, rawAccessorFn);\r\n    } else {\r\n      setNpValue(context, rawAccessorFn);\r\n    }\r\n\r\n    postChangeEvents(context);\r\n\r\n  } finally {\r\n    inProcess.pop();\r\n  }\r\n}\r\n\r\ninterface IContext {\r\n  parent: StructuralObject;\r\n  property: EntityProperty;\r\n  propertyName: string;\r\n  entityAspect: EntityAspect;\r\n  oldValue: any;\r\n  newValue: any;\r\n}\r\n\r\nfunction setDpValueSimple(context: IContext, rawAccessorFn: any) {\r\n  let parent = context.parent;\r\n  let property = context.property as DataProperty;\r\n  let entityAspect = context.entityAspect;\r\n  let oldValue = context.oldValue;\r\n  let newValue = context.newValue;\r\n\r\n  let entityManager = entityAspect.entityManager;\r\n\r\n  if (!property.isScalar) {\r\n    throw new Error(\"Nonscalar data properties are readonly - items may be added or removed but the collection may not be changed.\");\r\n  }\r\n\r\n  // store an original value for this property if not already set\r\n  if (entityAspect.entityState.isUnchangedOrModified()) {\r\n    let propName = property.name;\r\n    // localAspect is not the same as entityAspect for complex props\r\n    let localAspect = EntityAspect.isEntity(parent) ? parent.entityAspect : parent.complexAspect;\r\n    if (localAspect.originalValues[propName] === undefined) {\r\n      // otherwise this entry will be skipped during serialization\r\n      localAspect.originalValues[propName] = oldValue !== undefined ? oldValue : property.defaultValue;\r\n    }\r\n  }\r\n\r\n  // if we are changing the key update our internal entityGroup indexes.\r\n  if (property.isPartOfKey && entityManager && !entityManager.isLoading) {\r\n    // 'entityType' on the next line be null for complex properties but it will only be ref'd within this\r\n    // fn when the property is part of the key\r\n    let entityType = (parent as Entity).entityType;\r\n    let keyProps = entityType.keyProperties;\r\n    let values = keyProps.map(function (p) {\r\n      if (p === property) {\r\n        return newValue;\r\n      } else {\r\n        return parent.getProperty(p.name);\r\n      }\r\n    });\r\n    let newKey = new EntityKey(entityType, values);\r\n    if (entityManager.getEntityByKey(newKey)) {\r\n      throw new Error(\"An entity with this key is already in the cache: \" + newKey.toString());\r\n    }\r\n    let oldKey = (parent as Entity).entityAspect.getKey();\r\n    let eg = entityManager._findEntityGroup(entityType);\r\n    eg._replaceKey(oldKey, newKey);\r\n  }\r\n\r\n  // process related updates ( the inverse relationship) first so that collection dups check works properly.\r\n  // update inverse relationship\r\n\r\n  let relatedNavProp = property.relatedNavigationProperty;\r\n  if (relatedNavProp && entityManager) {\r\n    // Example: bidirectional fkDataProperty: 1->n: order -> orderDetails\r\n    // orderDetail.orderId <- newOrderId || null\r\n    //    ==> orderDetail.order = lookupOrder(newOrderId)\r\n    //    ==> (see set navProp above)\r\n    //       and\r\n    // Example: bidirectional fkDataProperty: 1->1: order -> internationalOrder\r\n    // internationalOrder.orderId <- newOrderId || null\r\n    //    ==> internationalOrder.order = lookupOrder(newOrderId)\r\n    //    ==> (see set navProp above)\r\n\r\n    if (newValue != null) {\r\n      let relatedEntity: Entity;\r\n      let key: EntityKey;\r\n      if (relatedNavProp.invForeignKeyNames.length) {\r\n        // property is related by field which is not the PK\r\n        const query = new EntityQuery(relatedNavProp.entityType.defaultResourceName).where(relatedNavProp.invForeignKeyNames[0], 'eq', newValue);\r\n        const qresult = entityManager.executeQueryLocally(query);\r\n        if (qresult.length === 1) {\r\n          relatedEntity = qresult[0];\r\n        }\r\n      } else {\r\n        // property is related by the PK\r\n        key = new EntityKey(relatedNavProp.entityType, [newValue]);\r\n        relatedEntity = entityManager.getEntityByKey(key);\r\n      }\r\n\r\n      if (relatedEntity) {\r\n        parent.setProperty(relatedNavProp.name, relatedEntity);\r\n      } else {\r\n        // it may not have been fetched yet in which case we want to add it as an unattachedChild.\r\n        if (key) {\r\n          // TODO currently _linkRelatedentities only works with PK relations, so we only add those.\r\n          entityManager._unattachedChildrenMap.addChild(key, relatedNavProp, parent as Entity);\r\n        }\r\n        parent.setProperty(relatedNavProp.name, null);\r\n      }\r\n    } else {\r\n      parent.setProperty(relatedNavProp.name, null);\r\n    }\r\n  } else if (property.inverseNavigationProperty && entityManager && !entityManager._inKeyFixup) {\r\n    // Example: unidirectional fkDataProperty: 1->n: region -> territories\r\n    // territory.regionId <- newRegionId\r\n    //    ==> lookupRegion(newRegionId).territories.push(territory)\r\n    //                and\r\n    // Example: unidirectional fkDataProperty: 1->1: order -> internationalOrder\r\n    // internationalOrder.orderId <- newOrderId\r\n    //    ==> lookupOrder(newOrderId).internationalOrder = internationalOrder\r\n    //                and\r\n    // Example: unidirectional fkDataProperty: 1->n: region -> territories\r\n    // territory.regionId <- null\r\n    //    ==> lookupRegion(territory.oldRegionId).territories.remove(oldTerritory);\r\n    //                and\r\n    // Example: unidirectional fkDataProperty: 1->1: order -> internationalOrder\r\n    // internationalOrder.orderId <- null\r\n    //    ==> lookupOrder(internationalOrder.oldOrderId).internationalOrder = null;\r\n\r\n    let invNavProp = property.inverseNavigationProperty;\r\n\r\n    if (oldValue != null) {\r\n      let key = new EntityKey(invNavProp.parentType, [oldValue]);\r\n      let relatedEntity = entityManager.getEntityByKey(key);\r\n      if (relatedEntity) {\r\n        if (invNavProp.isScalar) {\r\n          relatedEntity.setProperty(invNavProp.name, null);\r\n        } else {\r\n          // remove 'this' from old related nav prop\r\n          let relatedArray = relatedEntity.getProperty(invNavProp.name);\r\n          // arr.splice(arr.indexOf(value_to_remove), 1);\r\n          relatedArray.splice(relatedArray.indexOf(parent), 1);\r\n        }\r\n      }\r\n    }\r\n\r\n    if (newValue != null) {\r\n      let key = new EntityKey(invNavProp.parentType, [newValue]);\r\n      let relatedEntity = entityManager.getEntityByKey(key);\r\n\r\n      if (relatedEntity) {\r\n        if (invNavProp.isScalar) {\r\n          relatedEntity.setProperty(invNavProp.name, parent);\r\n        } else {\r\n          relatedEntity.getProperty(invNavProp.name).push(parent);\r\n        }\r\n      } else {\r\n        // it may not have been fetched yet in which case we want to add it as an unattachedChild.\r\n        entityManager._unattachedChildrenMap.addChild(key, invNavProp, parent as Entity);\r\n      }\r\n    }\r\n\r\n  }\r\n\r\n  rawAccessorFn(newValue);\r\n\r\n  updateStateAndValidate(context);\r\n\r\n  // if (property.isPartOfKey && (!this.complexAspect)) {\r\n  if (property.isPartOfKey) {\r\n    // propogate pk change to all related entities;\r\n    let entityType = (parent as Entity).entityType;\r\n    let propertyIx = entityType.keyProperties.indexOf(property);\r\n    // this part handles order.orderId => orderDetail.orderId\r\n    // but won't handle product.productId => orderDetail.productId because product\r\n    // doesn't have an orderDetails property.\r\n    entityType.navigationProperties.forEach(function (np) {\r\n      let inverseNp = np.inverse;\r\n      let fkNames = inverseNp ? inverseNp.foreignKeyNames : np.invForeignKeyNames;\r\n\r\n      if (fkNames.length === 0) return;\r\n      let npValue = parent.getProperty(np.name);\r\n      if (!npValue) return;\r\n      let fkName = fkNames[propertyIx];\r\n      if (np.isScalar) {\r\n        npValue.setProperty(fkName, newValue);\r\n      } else {\r\n        npValue.slice(0).forEach(function (iv: any) {\r\n          iv.setProperty(fkName, newValue);\r\n        });\r\n      }\r\n    });\r\n    // this handles unidirectional problems not covered above.\r\n    if (entityManager) {\r\n      let inverseForeignKeyProperties = entityType.inverseForeignKeyProperties;\r\n      let baseEntityType = entityType.baseEntityType;\r\n      while (baseEntityType) {\r\n        inverseForeignKeyProperties = inverseForeignKeyProperties.concat(baseEntityType.inverseForeignKeyProperties);\r\n        baseEntityType = baseEntityType.baseEntityType;\r\n      }\r\n      inverseForeignKeyProperties.forEach((invFkProp) => {\r\n        if (invFkProp.relatedNavigationProperty!.inverse == null) {\r\n          // this next step may be slow - it iterates over all of the entities in a group;\r\n          // hopefully it doesn't happen often.\r\n          entityManager!._updateFkVal(invFkProp, oldValue, newValue);\r\n        }\r\n        \r\n      });\r\n    }\r\n\r\n    // insure that cached key is updated.\r\n    entityAspect.getKey(true);\r\n  }\r\n}\r\n\r\nfunction setDpValueComplex(context: IContext, rawAccessorFn: Function) {\r\n  let property = context.property as DataProperty;\r\n  let oldValue = context.oldValue;\r\n  let newValue = context.newValue;\r\n\r\n  // To get here it must be a ComplexProperty\r\n  // 'dataType' will be a complexType\r\n  let dataType = property.dataType as ComplexType;\r\n  if (property.isScalar) {\r\n    if (!newValue) {\r\n      throw new Error(core.formatString(\"You cannot set the '%1' property to null because its datatype is the ComplexType: '%2'\", property.name, property.dataType.name));\r\n    }\r\n\r\n    if (!oldValue) {\r\n      let ctor = dataType.getCtor();\r\n      oldValue = new ctor();\r\n      rawAccessorFn(oldValue);\r\n    }\r\n    dataType.dataProperties.forEach(function (dp) {\r\n      let pn = dp.name;\r\n      let nv = newValue.getProperty(pn);\r\n      oldValue.setProperty(pn, nv);\r\n    });\r\n  } else {\r\n    throw new Error(core.formatString(\"You cannot set the non-scalar complex property: '%1' on the type: '%2'.\" +\r\n            \"Instead get the property and use array functions like 'push' or 'splice' to change its contents.\",\r\n        property.name, property.parentType.name));\r\n  }\r\n}\r\n\r\n\r\nfunction setNpValue(context: IContext, rawAccessorFn: Function) {\r\n\r\n  let parent = context.parent as Entity;\r\n  let property = context.property as NavigationProperty;\r\n  let entityAspect = context.entityAspect;\r\n  let oldValue = context.oldValue;\r\n  let newValue = context.newValue;\r\n\r\n  if (!property.isScalar) {\r\n    throw new Error(\"Nonscalar navigation properties are readonly - entities can be added or removed but the collection may not be changed.\");\r\n  }\r\n\r\n  let entityManager = entityAspect.entityManager;\r\n  let inverseProp = property.inverse;\r\n\r\n  // manage attachment -\r\n  if (newValue != null) {\r\n    if (!newValue.entityAspect) {\r\n      return;\r\n    }\r\n    let newAspect = newValue.entityAspect;\r\n    if (entityManager) {\r\n      if (newAspect.entityState.isDetached()) {\r\n        if (!entityManager.isLoading) {\r\n          entityManager.attachEntity(newValue, EntityState.Added);\r\n        }\r\n      } else {\r\n        if (newAspect.entityManager !== entityManager) {\r\n          throw new Error(\"An Entity cannot be attached to an entity in another EntityManager. One of the two entities must be detached first.\");\r\n        }\r\n      }\r\n    } else {\r\n      if (newAspect && newAspect.entityManager) {\r\n        entityManager = newAspect.entityManager;\r\n        if (!entityManager!.isLoading) {\r\n          entityManager!.attachEntity(entityAspect.entity!, EntityState.Added);\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  // process related updates ( the inverse relationship) first so that collection dups check works properly.\r\n  // update inverse relationship\r\n  if (inverseProp) {\r\n    ///\r\n    if (inverseProp.isScalar) {\r\n      // Example: bidirectional navProperty: 1->1: order -> internationalOrder\r\n      // order.internationalOrder <- internationalOrder || null\r\n      //    ==> (oldInternationalOrder.order = null)\r\n      //    ==> internationalOrder.order = order\r\n      if (oldValue != null) {\r\n        // TODO: null -> NullEntity later\r\n        oldValue.setProperty(inverseProp.name, null);\r\n      }\r\n      if (newValue != null) {\r\n        newValue.setProperty(inverseProp.name, parent);\r\n      }\r\n    } else {\r\n      // Example: bidirectional navProperty: 1->n: order -> orderDetails\r\n      // orderDetail.order <- newOrder || null\r\n      //    ==> (oldOrder).orderDetails.remove(orderDetail)\r\n      //    ==> order.orderDetails.push(newOrder)\r\n      if (oldValue != null) {\r\n        let oldSiblings = oldValue.getProperty(inverseProp.name);\r\n        let ix = oldSiblings.indexOf(parent);\r\n        if (ix !== -1) {\r\n          oldSiblings.splice(ix, 1);\r\n        }\r\n      }\r\n      if (newValue != null) {\r\n        let siblings = newValue.getProperty(inverseProp.name);\r\n        // recursion check if already in the collection is performed by the relationArray\r\n        siblings.push(parent);\r\n      }\r\n    }\r\n  } else if (property.invForeignKeyNames && entityManager && !entityManager._inKeyFixup) {\r\n    let invForeignKeyNames = property.invForeignKeyNames;\r\n    if (newValue != null) {\r\n      // Example: unidirectional navProperty: 1->1: order -> internationalOrder\r\n      // order.InternationalOrder <- internationalOrder\r\n      //    ==> internationalOrder.orderId = orderId\r\n      //      and\r\n      // Example: unidirectional navProperty: 1->n: order -> orderDetails\r\n      // orderDetail.order <-xxx newOrder\r\n      //    ==> CAN'T HAPPEN because if unidirectional because orderDetail will not have an order prop\r\n      let pkValues = parent.entityAspect.getKey().values;\r\n      invForeignKeyNames.forEach( (fkName, i) => {\r\n        newValue!.setProperty(fkName, pkValues[i]);\r\n      });\r\n    } else {\r\n      // Example: unidirectional navProperty: 1->1: order -> internationalOrder\r\n      // order.internationalOrder <- null\r\n      //    ==> (old internationalOrder).orderId = null\r\n      //        and\r\n      // Example: unidirectional navProperty: 1->n: order -> orderDetails\r\n      // orderDetail.order <-xxx newOrder\r\n      //    ==> CAN'T HAPPEN because if unidirectional because orderDetail will not have an order prop\r\n      if (oldValue != null) {\r\n        invForeignKeyNames.forEach( (fkName) => {\r\n          let fkProp = oldValue.entityType.getProperty(fkName);\r\n          if (!fkProp.isPartOfKey) {\r\n            // don't update with null if fk is part of the key\r\n            oldValue.setProperty(fkName, null);\r\n          }\r\n        });\r\n      }\r\n    }\r\n  }\r\n\r\n  rawAccessorFn(newValue);\r\n\r\n  updateStateAndValidate(context);\r\n\r\n  // update fk data property - this can only occur if this navProperty has\r\n  // a corresponding fk on this entity.\r\n  if (property.relatedDataProperties) {\r\n    let entityState = entityAspect.entityState;\r\n    // if either side of nav prop is detached don't clear fks. Note: oldValue in next line cannot be null so no check is needed.\r\n    if (newValue == null && (entityState.isDetached() || oldValue.entityAspect.entityState.isDetached())) return;\r\n    if (entityState.isDeleted()) return;\r\n\r\n    // we may have inverse props indicating the related prop on the other entity, if it is not the other entity's PK\r\n    let inverseKeyProps = property.invForeignKeyNames;\r\n    if (!(inverseKeyProps && inverseKeyProps.length)) {\r\n      // otherwise, this prop is related to the other entity's PK\r\n      inverseKeyProps = property.entityType.keyProperties.map(k => k.name);\r\n    }\r\n    inverseKeyProps.forEach(function (keyProp, i) {\r\n      let relatedDataProp = property.relatedDataProperties[i];\r\n      // Do not trash related property if it is part of that entity's key\r\n      if (newValue || !relatedDataProp.isPartOfKey) {\r\n        let relatedValue = newValue ? newValue.getProperty(keyProp) : relatedDataProp.defaultValue;\r\n        parent.setProperty(relatedDataProp.name, relatedValue);\r\n      }\r\n    });\r\n  }\r\n}\r\n\r\nfunction postChangeEvents(context: IContext) {\r\n  let entityAspect = context.entityAspect;\r\n\r\n  let entityManager = entityAspect.entityManager;\r\n  let entity = entityAspect.entity;\r\n\r\n  let propChangedArgs = { entity: entity!, parent: context.parent, property: context.property, propertyName: context.propertyName, oldValue: context.oldValue, newValue: context.newValue };\r\n  if (entityManager) {\r\n    // propertyChanged will be fired during loading but we only want to fire it once per entity, not once per property.\r\n    // so propertyChanged is fired in the entityManager mergeEntity method if not fired here.\r\n    if ((!entityManager.isLoading) && (!entityManager.isRejectingChanges)) {\r\n      entityAspect.propertyChanged.publish(propChangedArgs);\r\n      // don't fire entityChanged event if propertyChanged is suppressed.\r\n      entityManager.entityChanged.publish({ entityAction: EntityAction.PropertyChange, entity: entity, args: propChangedArgs });\r\n    }\r\n  } else {\r\n    entityAspect.propertyChanged.publish(propChangedArgs);\r\n  }\r\n}\r\n\r\nfunction updateStateAndValidate(context: IContext) {\r\n  let entityAspect = context.entityAspect;\r\n  let entityManager = entityAspect.entityManager;\r\n  if (entityManager == null || entityManager.isLoading) return;\r\n  let property = context.property;\r\n\r\n  if (entityAspect.entityState.isUnchanged() && !property.isUnmapped) {\r\n    entityAspect.setModified();\r\n  }\r\n\r\n  if (entityManager.validationOptions.validateOnPropertyChange) {\r\n    // entityAspect.entity is NOT the same as parent in the code below. It's use is deliberate.\r\n    entityAspect._validateProperty(context.newValue,\r\n        { entity: entityAspect.entity, property: property, propertyName: context.propertyName, oldValue: context.oldValue });\r\n  }\r\n}\r\n"]}

package/{esm2022/src/entity-action.mjs → esm2015/src/entity-action.js}

@@ -3,30 +3,6 @@ import { BreezeEnum } from './enum';
  
 */
 export class EntityAction extends BreezeEnum {
-    /** Entity was attached via an AttachEntity call. */
-    static Attach = new EntityAction({ _isAttach: true });
-    /**  Entity was attached as a result of a query. */
-    static AttachOnQuery = new EntityAction({ _isAttach: true });
-    /**  Entity was attached as a result of an import. */
-    static AttachOnImport = new EntityAction({ _isAttach: true });
-    /** Entity was detached */
-    static Detach = new EntityAction({ _isDetach: true });
-    /** Properties on the entity were merged as a result of a query. */
-    static MergeOnQuery = new EntityAction({ _isModification: true });
-    /** Properties on the entity were merged as a result of an import. */
-    static MergeOnImport = new EntityAction({ _isModification: true });
-    /** Properties on the entity were merged as a result of a save */
-    static MergeOnSave = new EntityAction({ _isModification: true });
-    /** A property on the entity was changed. */
-    static PropertyChange = new EntityAction({ _isModification: true });
-    /** The EntityState of the entity was changed. */
-    static EntityStateChange = new EntityAction();
-    /** AcceptChanges was called on the entity, or its entityState was set to Unmodified. */
-    static AcceptChanges = new EntityAction();
-    /** RejectChanges was called on the entity. */
-    static RejectChanges = new EntityAction({ _isModification: true });
-    /** The EntityManager was cleared.  All entities detached. */
-    static Clear = new EntityAction({ _isDetach: true });
     /** Is this an 'attach' operation? ( Attach, AttachOnQuery or AttachOnImport) */
     isAttach() {
         return !!this._isAttach;
@@ -40,6 +16,30 @@ export class EntityAction extends BreezeEnum {
         return !!this._isModification;
     }
 }
+/** Entity was attached via an AttachEntity call. */
+EntityAction.Attach = new EntityAction({ _isAttach: true });
+/**  Entity was attached as a result of a query. */
+EntityAction.AttachOnQuery = new EntityAction({ _isAttach: true });
+/**  Entity was attached as a result of an import. */
+EntityAction.AttachOnImport = new EntityAction({ _isAttach: true });
+/** Entity was detached */
+EntityAction.Detach = new EntityAction({ _isDetach: true });
+/** Properties on the entity were merged as a result of a query. */
+EntityAction.MergeOnQuery = new EntityAction({ _isModification: true });
+/** Properties on the entity were merged as a result of an import. */
+EntityAction.MergeOnImport = new EntityAction({ _isModification: true });
+/** Properties on the entity were merged as a result of a save */
+EntityAction.MergeOnSave = new EntityAction({ _isModification: true });
+/** A property on the entity was changed. */
+EntityAction.PropertyChange = new EntityAction({ _isModification: true });
+/** The EntityState of the entity was changed. */
+EntityAction.EntityStateChange = new EntityAction();
+/** AcceptChanges was called on the entity, or its entityState was set to Unmodified. */
+EntityAction.AcceptChanges = new EntityAction();
+/** RejectChanges was called on the entity. */
+EntityAction.RejectChanges = new EntityAction({ _isModification: true });
+/** The EntityManager was cleared.  All entities detached. */
+EntityAction.Clear = new EntityAction({ _isDetach: true });
 EntityAction.prototype._$typeName = "EntityAction";
 Error['x'] = EntityAction.resolveSymbols();
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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