breeze-client
Version:
Breeze data management for JavaScript clients
173 lines • 23.7 kB
JavaScript
import { core } from './core';
import { EntityQuery } from './entity-query';
import { EntityState } from './entity-state';
import { BreezeEvent } from './event';
import { observableArray } from './observable-array';
let relationArrayMixin = {
/**
Relation arrays are not actually classes, they are objects that mimic arrays. A relation array is collection of
entities associated with a navigation property on a single entity. i.e. customer.orders or order.orderDetails.
This collection looks like an array in that the basic methods on arrays such as 'push', 'pop', 'shift', 'unshift', 'splice'
are all provided as well as several special purpose methods.
@class {relationArray}
**/
/**
An [[Event]] that fires whenever the contents of this array changed. This event
is fired any time a new entity is attached or added to the EntityManager and happens to belong to this collection.
Adds that occur as a result of query or import operations are batched so that all of the adds or removes to any individual
collections are collected into a single notification event for each relation array.
@example
// assume order is an order entity attached to an EntityManager.
orders.arrayChanged.subscribe(
function (arrayChangedArgs) {
let addedEntities = arrayChangedArgs.added;
let removedEntities = arrayChanged.removed;
});
@event arrayChanged
@param added {Array of Entity} An array of all of the entities added to this collection.
@param removed {Array of Entity} An array of all of the removed from this collection.
@readOnly
**/
/**
Performs an asynchronous load of all other the entities associated with this relationArray.
@example
// assume orders is an empty, as yet unpopulated, relation array of orders
// associated with a specific customer.
orders.load().then(...)
@method load
@param [callback] {Function}
@param [errorCallback] {Function}
@return {Promise}
**/
load: function (callback, errorCallback) {
let parent = this.parentEntity;
let query = EntityQuery.fromEntityNavigation(this.parentEntity, this.navigationProperty);
let em = parent.entityAspect.entityManager;
return em.executeQuery(query, callback, errorCallback);
},
_getEventParent: function () {
return this.parentEntity.entityAspect;
},
_getPendingPubs: function () {
let em = this.parentEntity.entityAspect.entityManager;
return em && em._pendingPubs;
},
// virtual impls
_getGoodAdds: function (adds) {
return getGoodAdds(this, adds);
},
_processAdds: function (adds) {
processAdds(this, adds);
},
_processRemoves: function (removes) {
processRemoves(this, removes);
}
};
function getGoodAdds(relationArray, adds) {
let goodAdds = checkForDups(relationArray, adds);
if (!goodAdds.length) {
return goodAdds;
}
let parentEntity = relationArray.parentEntity;
let entityManager = parentEntity.entityAspect.entityManager;
// we do not want to attach an entity during loading
// because these will all be 'attached' at a later step.
if (entityManager && !entityManager.isLoading) {
goodAdds.forEach(function (add) {
if (add.entityAspect.entityState.isDetached()) {
relationArray._inProgress = true;
try {
entityManager.attachEntity(add, EntityState.Added);
}
finally {
relationArray._inProgress = false;
}
}
});
}
return goodAdds;
}
function processAdds(relationArray, adds) {
let parentEntity = relationArray.parentEntity;
let np = relationArray.navigationProperty;
let addsInProcess = relationArray._addsInProcess;
let invNp = np.inverse;
let startIx = addsInProcess.length;
try {
adds.forEach(function (childEntity) {
addsInProcess.push(childEntity);
if (invNp) {
childEntity.setProperty(invNp.name, parentEntity);
}
else {
// This occurs with a unidirectional 1-n navigation - in this case
// we need to update the fks instead of the navProp
let pks = parentEntity.entityType.keyProperties;
np.invForeignKeyNames.forEach(function (fk, i) {
childEntity.setProperty(fk, parentEntity.getProperty(pks[i].name));
});
}
});
}
finally {
addsInProcess.splice(startIx, adds.length);
}
}
function processRemoves(relationArray, removes) {
let inp = relationArray.navigationProperty.inverse;
if (inp) {
removes.forEach(function (childEntity) {
childEntity.setProperty(inp.name, null);
});
}
}
function checkForDups(relationArray, adds) {
// don't allow dups in this array. - also prevents recursion
let parentEntity = relationArray.parentEntity;
let navProp = relationArray.navigationProperty;
let inverseProp = navProp.inverse;
let goodAdds;
if (inverseProp) {
goodAdds = adds.filter(function (a) {
if (relationArray._addsInProcess.indexOf(a) >= 0) {
return false;
}
let inverseValue = a.getProperty(inverseProp.name);
return inverseValue !== parentEntity;
});
}
else {
// This occurs with a unidirectional 1->N relation ( where there is no n -> 1)
// in this case we compare fks.
let fkPropNames = navProp.invForeignKeyNames;
let keyProps = parentEntity.entityType.keyProperties;
goodAdds = adds.filter(function (a) {
if (relationArray._addsInProcess.indexOf(a) >= 0) {
return false;
}
return fkPropNames.some(function (fk, i) {
let keyProp = keyProps[i].name;
let keyVal = parentEntity.getProperty(keyProp);
let fkVal = a.getProperty(fk);
return keyVal !== fkVal;
});
});
}
return goodAdds;
}
/** For use by breeze plugin authors only. The class is for use in building a [[IModelLibraryAdapter]] implementation.
@adapter (see [[IModelLibraryAdapter]])
@hidden
*/
export function makeRelationArray(arr, parentEntity, navigationProperty) {
let arrX = arr;
arrX.parentEntity = parentEntity;
arrX.navigationProperty = navigationProperty;
arrX.arrayChanged = new BreezeEvent("arrayChanged", arrX);
// array of pushes currently in process on this relation array - used to prevent recursion.
arrX._addsInProcess = [];
// need to use mixins here instead of inheritance because we are starting from an existing array object.
core.extend(arrX, observableArray.mixin);
return core.extend(arrX, relationArrayMixin);
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"relation-array.js","sourceRoot":"","sources":["../../../src/relation-array.ts"],"names":[],"mappings":"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","sourcesContent":["import { core } from './core';\r\nimport { Entity } from './entity-aspect';\r\nimport { QueryErrorCallback, QueryResult, QuerySuccessCallback } from './entity-manager';\r\nimport { DataProperty, NavigationProperty } from './entity-metadata';\r\nimport { EntityQuery } from './entity-query';\r\nimport { EntityState } from './entity-state';\r\nimport { BreezeEvent } from './event';\r\nimport { ObservableArray, observableArray } from './observable-array';\r\n\r\n// TODO: mixin impl is not very typesafe\r\n\r\nexport interface RelationArray extends ObservableArray {\r\n  [index: number]: Entity;\r\n  parentEntity: Entity;\r\n  parentProperty?: DataProperty;\r\n  navigationProperty: NavigationProperty;\r\n  _inProgress?: boolean;\r\n  _addsInProcess: Entity[];\r\n  load(querySuccessCallback?: QuerySuccessCallback, queryErrorCallback?: QueryErrorCallback): Promise<QueryResult>; \r\n}\r\n\r\nlet relationArrayMixin = {\r\n\r\n  /**\r\n  Relation arrays are not actually classes, they are objects that mimic arrays. A relation array is collection of\r\n  entities associated with a navigation property on a single entity. i.e. customer.orders or order.orderDetails.\r\n  This collection looks like an array in that the basic methods on arrays such as 'push', 'pop', 'shift', 'unshift', 'splice'\r\n  are all provided as well as several special purpose methods.\r\n  @class {relationArray}\r\n  **/\r\n\r\n  /**\r\n  An [[Event]] that fires whenever the contents of this array changed.  This event\r\n  is fired any time a new entity is attached or added to the EntityManager and happens to belong to this collection.\r\n  Adds that occur as a result of query or import operations are batched so that all of the adds or removes to any individual\r\n  collections are collected into a single notification event for each relation array.\r\n  @example\r\n      // assume order is an order entity attached to an EntityManager.\r\n      orders.arrayChanged.subscribe(\r\n      function (arrayChangedArgs) {\r\n          let addedEntities = arrayChangedArgs.added;\r\n          let removedEntities = arrayChanged.removed;\r\n      });\r\n  @event arrayChanged\r\n  @param added {Array of Entity} An array of all of the entities added to this collection.\r\n  @param removed {Array of Entity} An array of all of the removed from this collection.\r\n  @readOnly\r\n  **/\r\n\r\n\r\n  /**\r\n  Performs an asynchronous load of all other the entities associated with this relationArray.\r\n  @example\r\n      // assume orders is an empty, as yet unpopulated, relation array of orders\r\n      // associated with a specific customer.\r\n      orders.load().then(...)\r\n  @method load\r\n  @param [callback] {Function}\r\n  @param [errorCallback] {Function}\r\n  @return {Promise}\r\n  **/\r\n  load: function(callback?: QuerySuccessCallback, errorCallback?: QueryErrorCallback): Promise<QueryResult> {\r\n    let parent = this.parentEntity;\r\n    let query = EntityQuery.fromEntityNavigation(this.parentEntity, this.navigationProperty);\r\n    let em = parent.entityAspect.entityManager;\r\n    return em.executeQuery(query, callback, errorCallback);\r\n  },\r\n\r\n  _getEventParent: function() {\r\n    return this.parentEntity.entityAspect;\r\n  },\r\n\r\n  _getPendingPubs: function() {\r\n    let em = this.parentEntity.entityAspect.entityManager;\r\n    return em && em._pendingPubs;\r\n  },\r\n\r\n  // virtual impls\r\n  _getGoodAdds: function(adds: Entity[]) {\r\n    return getGoodAdds(this, adds);\r\n  },\r\n\r\n  _processAdds: function(adds: Entity[]) {\r\n    processAdds(this, adds);\r\n  },\r\n\r\n  _processRemoves: function(removes: Entity[]) {\r\n    processRemoves(this, removes);\r\n  }\r\n\r\n};\r\n\r\nfunction getGoodAdds(relationArray: RelationArray, adds: Entity[]) {\r\n  let goodAdds = checkForDups(relationArray, adds);\r\n  if (!goodAdds.length) {\r\n    return goodAdds;\r\n  }\r\n  let parentEntity = relationArray.parentEntity;\r\n  let entityManager = parentEntity.entityAspect.entityManager;\r\n  // we do not want to attach an entity during loading\r\n  // because these will all be 'attached' at a later step.\r\n  if (entityManager && !entityManager.isLoading) {\r\n    goodAdds.forEach(function (add) {\r\n      if (add.entityAspect.entityState.isDetached()) {\r\n        relationArray._inProgress = true;\r\n        try {\r\n          entityManager!.attachEntity(add, EntityState.Added);\r\n        } finally {\r\n          relationArray._inProgress = false;\r\n        }\r\n      }\r\n    });\r\n  }\r\n  return goodAdds;\r\n}\r\n\r\nfunction processAdds(relationArray: RelationArray, adds: Entity[]) {\r\n  let parentEntity = relationArray.parentEntity;\r\n  let np = relationArray.navigationProperty;\r\n  let addsInProcess = relationArray._addsInProcess;\r\n\r\n  let invNp = np.inverse;\r\n  let startIx = addsInProcess.length;\r\n  try {\r\n    adds.forEach(function (childEntity) {\r\n      addsInProcess.push(childEntity);\r\n      if (invNp) {\r\n        childEntity.setProperty(invNp.name, parentEntity);\r\n      } else {\r\n        // This occurs with a unidirectional 1-n navigation - in this case\r\n        // we need to update the fks instead of the navProp\r\n        let pks = parentEntity.entityType.keyProperties;\r\n        np.invForeignKeyNames.forEach(function (fk, i) {\r\n          childEntity.setProperty(fk, parentEntity.getProperty(pks[i].name));\r\n        });\r\n      }\r\n    });\r\n  } finally {\r\n    addsInProcess.splice(startIx, adds.length);\r\n  }\r\n\r\n}\r\n\r\nfunction processRemoves(relationArray: RelationArray, removes: Entity[]) {\r\n  let inp = relationArray.navigationProperty.inverse;\r\n  if (inp) {\r\n    removes.forEach(function (childEntity) {\r\n      childEntity.setProperty(inp!.name, null);\r\n    });\r\n  }\r\n}\r\n\r\nfunction checkForDups(relationArray: RelationArray, adds: Entity[]) {\r\n  // don't allow dups in this array. - also prevents recursion\r\n  let parentEntity = relationArray.parentEntity;\r\n  let navProp = relationArray.navigationProperty;\r\n  let inverseProp = navProp.inverse;\r\n  let goodAdds: Entity[];\r\n  if (inverseProp) {\r\n    goodAdds = adds.filter(function (a) {\r\n      if (relationArray._addsInProcess.indexOf(a) >= 0) {\r\n        return false;\r\n      }\r\n      let inverseValue = a.getProperty(inverseProp!.name);\r\n      return inverseValue !== parentEntity;\r\n    });\r\n  } else {\r\n    // This occurs with a unidirectional 1->N relation ( where there is no n -> 1)\r\n    // in this case we compare fks.\r\n    let fkPropNames = navProp.invForeignKeyNames;\r\n    let keyProps = parentEntity.entityType.keyProperties;\r\n    goodAdds = adds.filter(function (a) {\r\n      if (relationArray._addsInProcess.indexOf(a) >= 0) {\r\n        return false;\r\n      }\r\n      return fkPropNames.some(function (fk, i) {\r\n        let keyProp = keyProps[i].name;\r\n        let keyVal = parentEntity.getProperty(keyProp);\r\n        let fkVal = a.getProperty(fk);\r\n        return keyVal !== fkVal;\r\n      });\r\n    });\r\n  }\r\n  return goodAdds;\r\n}\r\n\r\n/** For use by breeze plugin authors only. The class is for use in building a [[IModelLibraryAdapter]] implementation. \r\n@adapter (see [[IModelLibraryAdapter]])    \r\n@hidden \r\n*/\r\nexport function makeRelationArray(arr: any[], parentEntity: Entity, navigationProperty: NavigationProperty): RelationArray {\r\n  let arrX = arr as any;\r\n  arrX.parentEntity = parentEntity;\r\n  arrX.navigationProperty = navigationProperty;\r\n  arrX.arrayChanged = new BreezeEvent(\"arrayChanged\", arrX);\r\n  // array of pushes currently in process on this relation array - used to prevent recursion.\r\n  arrX._addsInProcess = [];\r\n  // need to use mixins here instead of inheritance because we are starting from an existing array object.\r\n  core.extend(arrX, observableArray.mixin);\r\n  return core.extend(arrX, relationArrayMixin) as RelationArray;\r\n}\r\n"]}