breeze-client 2.1.7 → 2.2.0

package/esm2022/src/primitive-array.mjs

@@ -0,0 +1,85 @@
+import { core } from './core';
+import { observableArray } from './observable-array';
+import { BreezeEvent } from './event';
+// TODO: mixin impl is not very typesafe
+// Not needed
+// interface IPrimitiveArray extends IObservableArray {
+//   [index: number]: any;
+//   parent?: IStructuralObject;
+//   parentProperty?: DataProperty;
+// }
+let primitiveArrayMixin = {
+    // complexArray will have the following props
+    //    parent
+    //    propertyPath
+    //    parentProperty
+    //    addedItems  - only if modified
+    //    removedItems  - only if modified
+    //  each complexAspect of any entity within a complexArray
+    //  will have its own _complexState = "A/M";
+    /**
+    Primitive arrays are not actually classes, they are objects that mimic arrays. A primitive array is collection of
+    primitive types associated with a data property on a single entity or complex object. i.e. customer.invoiceNumbers.
+    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 {primitiveArray}
+    **/
+    /**
+    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 Primitives} An array of all of the items added to this collection.
+    @param removed {Array of Primitives} An array of all of the items removed from this collection.
+    @readOnly
+    **/
+    // virtual impls
+    _getGoodAdds: function (adds) {
+        return adds;
+    },
+    _beforeChange: function () {
+        let entityAspect = this.getEntityAspect();
+        if (entityAspect.entityState.isUnchanged()) {
+            entityAspect.setModified();
+        }
+        if (entityAspect.entityState.isModified() && !this._origValues) {
+            this._origValues = this.slice(0);
+        }
+    },
+    _processAdds: function (adds) {
+        // nothing needed
+    },
+    _processRemoves: function (removes) {
+        // nothing needed;
+    },
+    _rejectChanges: function () {
+        if (!this._origValues)
+            return;
+        this.length = 0;
+        Array.prototype.push.apply(this, this._origValues);
+    },
+    _acceptChanges: function () {
+        this._origValues = null;
+    }
+};
+// local functions
+/** For use by breeze plugin authors only. The class is for use in building a [[IModelLibraryAdapter]] implementation.
+@adapter (see [[IModelLibraryAdapter]])
+@hidden
+*/
+export function makePrimitiveArray(arr, parent, parentProperty) {
+    let arrX = arr;
+    observableArray.initializeParent(arrX, parent, parentProperty);
+    arrX.arrayChanged = new BreezeEvent("arrayChanged", arrX);
+    core.extend(arrX, observableArray.mixin);
+    return core.extend(arrX, primitiveArrayMixin);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/query-options.mjs

@@ -0,0 +1,160 @@
+import { core } from './core';
+import { BreezeEnum } from './enum';
+import { assertConfig } from './assert-param';
+/**
+MergeStrategy is an 'Enum' that determines how entities are merged into an EntityManager.
+
+@class MergeStrategy
+@static
+**/
+export class MergeStrategy extends BreezeEnum {
+    /**
+    MergeStrategy.PreserveChanges updates the cached entity with the incoming values unless the cached entity is in a changed
+    state (added, modified, deleted) in which case the incoming values are ignored. The updated cached entity’s EntityState will
+    remain [[EntityState.Unchanged]] unless you’re importing entities in which case the new EntityState will
+    be that of the imported entities.
+    **/
+    static PreserveChanges = new MergeStrategy();
+    /**
+    MergeStrategy.OverwriteChanges always updates the cached entity with incoming values even if the entity is in
+    a changed state (added, modified, deleted). After the merge, the pending changes are lost.
+    The new EntityState will be  [[EntityState/Unchanged]] unless you’re importing entities
+    in which case the new EntityState will be that of the imported entities.
+    **/
+    static OverwriteChanges = new MergeStrategy();
+    /**
+    SkipMerge is used to ignore incoming values. Adds the incoming entity to the cache only if there is no cached entity with the same key.
+    This is the fastest merge strategy but your existing cached data will remain “stale”.
+    **/
+    static SkipMerge = new MergeStrategy();
+    /**
+    Disallowed is used to throw an exception if there is an incoming entity with the same key as an entity already in the cache.
+    Use this strategy when you want to be sure that the incoming entity is not already in cache.
+    This is the default strategy for EntityManager.attachEntity.
+    **/
+    static Disallowed = new MergeStrategy();
+}
+MergeStrategy.prototype._$typeName = "MergeStrategy";
+Error['x'] = MergeStrategy.resolveSymbols();
+/**
+FetchStrategy is an 'Enum' that determines how and where entities are retrieved from as a result of a query.
+**/
+export class FetchStrategy extends BreezeEnum {
+    /**
+    FromServer is used to tell the query to execute the query against a remote data source on the server.
+    **/
+    static FromServer = new FetchStrategy();
+    /**
+    FromLocalCache is used to tell the query to execute the query against a local EntityManager instead of going to a remote server.
+    **/
+    static FromLocalCache = new FetchStrategy();
+}
+FetchStrategy.prototype._$typeName = "FetchStrategy";
+Error['x'] = FetchStrategy.resolveSymbols();
+/**
+A QueryOptions instance is used to specify the 'options' under which a query will occur.
+**/
+export class QueryOptions {
+    /** @hidden @internal */
+    _$typeName;
+    /** The [[FetchStrategy]] to use with any queries. __Read Only__ */
+    fetchStrategy;
+    /** The [[MergeStrategy]] to use with any queries. __Read Only__ */
+    mergeStrategy;
+    /** Whether to include cached deleted entities in a query result (false by default). __Read Only__ */
+    includeDeleted;
+    /**
+    The default instance for use whenever QueryOptions are not specified.
+    **/
+    static defaultInstance = new QueryOptions({
+        fetchStrategy: FetchStrategy.FromServer,
+        mergeStrategy: MergeStrategy.PreserveChanges,
+        includeDeleted: false
+    });
+    /**
+    QueryOptions constructor
+    >     var newQo = new QueryOptions( { mergeStrategy: MergeStrategy.OverwriteChanges });
+    >     // assume em1 is a preexisting EntityManager
+    >     em1.setProperties( { queryOptions: newQo });
+    Any QueryOptions property that is not defined will be defaulted from any QueryOptions defined at a higher level in the breeze hierarchy, i.e.
+    -  from query.queryOptions
+    -  to   entityManager.queryOptions
+    -  to   QueryOptions.defaultInstance;
+  
+    @param config - A configuration object.
+    **/
+    constructor(config) {
+        QueryOptions._updateWithConfig(this, config);
+    }
+    static resolve(queryOptionsArray) {
+        return new QueryOptions(core.resolveProperties(queryOptionsArray, ["fetchStrategy", "mergeStrategy", "includeDeleted"]));
+    }
+    /**
+    Returns a copy of this QueryOptions with the specified [[MergeStrategy]],
+    [[FetchStrategy]], or 'includeDeleted' option applied.
+    >     // Given an EntityManager instance, em
+    >     var queryOptions = em.queryOptions.using(MergeStrategy.PreserveChanges);
+  
+    or
+    >     var queryOptions = em.queryOptions.using(FetchStrategy.FromLocalCache);
+  
+    or
+    >     var queryOptions = em.queryOptions.using({ mergeStrategy: MergeStrategy.OverwriteChanges });
+  
+    or
+    >     var queryOptions = em.queryOptions.using({
+    >        includeDeleted: true,
+    >        fetchStrategy:  FetchStrategy.FromLocalCache
+    >     });
+    @param config - A configuration object or a standalone [[MergeStrategy]] or [[FetchStrategy]]
+    @return A new QueryOptions instance.
+    **/
+    using(qoConfig) {
+        if (!qoConfig)
+            return this;
+        let result = new QueryOptions(this);
+        if (qoConfig instanceof MergeStrategy) {
+            qoConfig = { mergeStrategy: qoConfig };
+        }
+        else if (qoConfig instanceof FetchStrategy) {
+            qoConfig = { fetchStrategy: qoConfig };
+        }
+        return QueryOptions._updateWithConfig(result, qoConfig);
+    }
+    /**
+    Sets the 'defaultInstance' by creating a copy of the current 'defaultInstance' and then applying all of the properties of the current instance.
+    The current instance is returned unchanged.
+    >     var newQo = new QueryOptions( { mergeStrategy: MergeStrategy.OverwriteChanges });
+    >     newQo.setAsDefault();
+    **/
+    setAsDefault() {
+        return core.setAsDefault(this, QueryOptions);
+    }
+    toJSON() {
+        return core.toJson(this, {
+            fetchStrategy: null,
+            mergeStrategy: null,
+            includeDeleted: false
+        });
+    }
+    static fromJSON(json) {
+        return new QueryOptions({
+            fetchStrategy: FetchStrategy.fromName(json.fetchStrategy),
+            mergeStrategy: MergeStrategy.fromName(json.mergeStrategy),
+            includeDeleted: json.includeDeleted === true
+        });
+    }
+    /** @hidden @internal */
+    static _updateWithConfig(obj, config) {
+        if (config) {
+            assertConfig(config)
+                .whereParam("fetchStrategy").isEnumOf(FetchStrategy).isOptional()
+                .whereParam("mergeStrategy").isEnumOf(MergeStrategy).isOptional()
+                .whereParam("includeDeleted").isBoolean().isOptional()
+                .applyAll(obj);
+        }
+        return obj;
+    }
+}
+QueryOptions.prototype._$typeName = "QueryOptions";
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-options.js","sourceRoot":"","sources":["../../../src/query-options.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AACpC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C;;;;;GAKG;AACH,MAAM,OAAO,aAAc,SAAQ,UAAU;IAE3C;;;;;OAKG;IACH,MAAM,CAAC,eAAe,GAAG,IAAI,aAAa,EAAE,CAAC;IAC7C;;;;;OAKG;IACH,MAAM,CAAC,gBAAgB,GAAG,IAAI,aAAa,EAAE,CAAC;IAE9C;;;OAGG;IACH,MAAM,CAAC,SAAS,GAAG,IAAI,aAAa,EAAE,CAAC;IAEvC;;;;OAIG;IACH,MAAM,CAAC,UAAU,GAAG,IAAI,aAAa,EAAE,CAAC;;AAI1C,aAAa,CAAC,SAAS,CAAC,UAAU,GAAG,eAAe,CAAC;AACrD,KAAK,CAAC,GAAG,CAAC,GAAG,aAAa,CAAC,cAAc,EAAE,CAAC;AAE5C;;GAEG;AACH,MAAM,OAAO,aAAc,SAAQ,UAAU;IAE3C;;OAEG;IACH,MAAM,CAAC,UAAU,GAAG,IAAI,aAAa,EAAE,CAAC;IACxC;;OAEG;IACH,MAAM,CAAC,cAAc,GAAG,IAAI,aAAa,EAAE,CAAC;;AAG9C,aAAa,CAAC,SAAS,CAAC,UAAU,GAAG,eAAe,CAAC;AACrD,KAAK,CAAC,GAAG,CAAC,GAAG,aAAa,CAAC,cAAc,EAAE,CAAC;AAY5C;;GAEG;AACH,MAAM,OAAO,YAAY;IACvB,wBAAwB;IACxB,UAAU,CAAS;IACnB,mEAAmE;IACnE,aAAa,CAAgB;IAC7B,mEAAmE;IACnE,aAAa,CAAgB;IAC7B,qGAAqG;IACrG,cAAc,CAAU;IAExB;;OAEG;IACH,MAAM,CAAC,eAAe,GAAG,IAAI,YAAY,CAAC;QACxC,aAAa,EAAE,aAAa,CAAC,UAAU;QACvC,aAAa,EAAE,aAAa,CAAC,eAAe;QAC5C,cAAc,EAAE,KAAK;KACtB,CAAC,CAAC;IAEH;;;;;;;;;;;OAWG;IACH,YAAY,MAA2B;QACrC,YAAY,CAAC,iBAAiB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IAC/C,CAAC;IAED,MAAM,CAAC,OAAO,CAAC,iBAAwB;QACrC,OAAO,IAAI,YAAY,CAAC,IAAI,CAAC,iBAAiB,CAAC,iBAAiB,EAAE,CAAC,eAAe,EAAE,eAAe,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAC;IAC3H,CAAC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,KAAK,CAAC,QAA4D;QAChE,IAAI,CAAC,QAAQ;YAAE,OAAO,IAAI,CAAC;QAC3B,IAAI,MAAM,GAAG,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;QACpC,IAAK,QAAQ,YAAY,aAAa,EAAE;YACtC,QAAQ,GAAG,EAAE,aAAa,EAAE,QAAQ,EAAE,CAAC;SACxC;aAAM,IAAK,QAAQ,YAAY,aAAa,EAAE;YAC7C,QAAQ,GAAG,EAAE,aAAa,EAAE,QAAQ,EAAE,CAAC;SACxC;QACD,OAAO,YAAY,CAAC,iBAAiB,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAC1D,CAAC;IAED;;;;;OAKG;IACH,YAAY;QACV,OAAO,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;IAC/C,CAAC;IAED,MAAM;QACJ,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE;YACvB,aAAa,EAAE,IAAI;YACnB,aAAa,EAAE,IAAI;YACnB,cAAc,EAAE,KAAK;SACtB,CAAC,CAAC;IACL,CAAC;IAED,MAAM,CAAC,QAAQ,CAAC,IAAS;QACvB,OAAO,IAAI,YAAY,CAAC;YACtB,aAAa,EAAE,aAAa,CAAC,QAAQ,CAAC,IAAI,CAAC,aAAa,CAAC;YACzD,aAAa,EAAE,aAAa,CAAC,QAAQ,CAAC,IAAI,CAAC,aAAa,CAAC;YACzD,cAAc,EAAE,IAAI,CAAC,cAAc,KAAK,IAAI;SAC7C,CAAC,CAAC;IACL,CAAC;IAED,wBAAwB;IAChB,MAAM,CAAC,iBAAiB,CAAC,GAAiB,EAAE,MAA2B;QAC7E,IAAI,MAAM,EAAE;YACV,YAAY,CAAC,MAAM,CAAC;iBACjB,UAAU,CAAC,eAAe,CAAC,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC,UAAU,EAAE;iBAChE,UAAU,CAAC,eAAe,CAAC,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC,UAAU,EAAE;iBAChE,UAAU,CAAC,gBAAgB,CAAC,CAAC,SAAS,EAAE,CAAC,UAAU,EAAE;iBACrD,QAAQ,CAAC,GAAG,CAAC,CAAC;SAClB;QACD,OAAO,GAAG,CAAC;IACb,CAAC;;AAGH,YAAY,CAAC,SAAS,CAAC,UAAU,GAAG,cAAc,CAAC","sourcesContent":["import { core } from './core';\r\nimport { BreezeEnum } from './enum';\r\nimport { assertConfig } from './assert-param';\r\n\r\n/**\r\nMergeStrategy is an 'Enum' that determines how entities are merged into an EntityManager.\r\n\r\n@class MergeStrategy\r\n@static\r\n**/\r\nexport class MergeStrategy extends BreezeEnum {\r\n\r\n  /**\r\n  MergeStrategy.PreserveChanges updates the cached entity with the incoming values unless the cached entity is in a changed\r\n  state (added, modified, deleted) in which case the incoming values are ignored. The updated cached entity’s EntityState will\r\n  remain [[EntityState.Unchanged]] unless you’re importing entities in which case the new EntityState will\r\n  be that of the imported entities.\r\n  **/\r\n  static PreserveChanges = new MergeStrategy();\r\n  /**\r\n  MergeStrategy.OverwriteChanges always updates the cached entity with incoming values even if the entity is in\r\n  a changed state (added, modified, deleted). After the merge, the pending changes are lost.\r\n  The new EntityState will be  [[EntityState/Unchanged]] unless you’re importing entities\r\n  in which case the new EntityState will be that of the imported entities.\r\n  **/\r\n  static OverwriteChanges = new MergeStrategy();\r\n\r\n  /**\r\n  SkipMerge is used to ignore incoming values. Adds the incoming entity to the cache only if there is no cached entity with the same key.\r\n  This is the fastest merge strategy but your existing cached data will remain “stale”.\r\n  **/\r\n  static SkipMerge = new MergeStrategy();\r\n\r\n  /**\r\n  Disallowed is used to throw an exception if there is an incoming entity with the same key as an entity already in the cache.\r\n  Use this strategy when you want to be sure that the incoming entity is not already in cache.\r\n  This is the default strategy for EntityManager.attachEntity.\r\n  **/\r\n  static Disallowed = new MergeStrategy();\r\n\r\n\r\n}\r\nMergeStrategy.prototype._$typeName = \"MergeStrategy\";\r\nError['x'] = MergeStrategy.resolveSymbols();\r\n\r\n/**\r\nFetchStrategy is an 'Enum' that determines how and where entities are retrieved from as a result of a query.\r\n**/\r\nexport class FetchStrategy extends BreezeEnum {\r\n\r\n  /**\r\n  FromServer is used to tell the query to execute the query against a remote data source on the server.\r\n  **/\r\n  static FromServer = new FetchStrategy();\r\n  /**\r\n  FromLocalCache is used to tell the query to execute the query against a local EntityManager instead of going to a remote server.\r\n  **/\r\n  static FromLocalCache = new FetchStrategy();\r\n\r\n}\r\nFetchStrategy.prototype._$typeName = \"FetchStrategy\";\r\nError['x'] = FetchStrategy.resolveSymbols();\r\n\r\n/** Configuration info to be passed to the [[QueryOptions]] constructor. */\r\nexport interface QueryOptionsConfig {\r\n  /** The [[FetchStrategy]] to use with any queries.*/\r\n  fetchStrategy?: FetchStrategy;\r\n  /** The [[MergeStrategy]] to use with any queries.*/\r\n  mergeStrategy?: MergeStrategy;\r\n  /** Whether to include cached deleted entities in a query result (false by default). __Read Only__ */\r\n  includeDeleted?: boolean;\r\n}\r\n\r\n/**\r\nA QueryOptions instance is used to specify the 'options' under which a query will occur.\r\n**/\r\nexport class QueryOptions {\r\n  /** @hidden @internal */\r\n  _$typeName: string;\r\n  /** The [[FetchStrategy]] to use with any queries. __Read Only__ */\r\n  fetchStrategy: FetchStrategy;\r\n  /** The [[MergeStrategy]] to use with any queries. __Read Only__ */\r\n  mergeStrategy: MergeStrategy;\r\n  /** Whether to include cached deleted entities in a query result (false by default). __Read Only__ */\r\n  includeDeleted: boolean;\r\n\r\n  /**\r\n  The default instance for use whenever QueryOptions are not specified.\r\n  **/\r\n  static defaultInstance = new QueryOptions({\r\n    fetchStrategy: FetchStrategy.FromServer,\r\n    mergeStrategy: MergeStrategy.PreserveChanges,\r\n    includeDeleted: false\r\n  });\r\n\r\n  /**\r\n  QueryOptions constructor\r\n  >     var newQo = new QueryOptions( { mergeStrategy: MergeStrategy.OverwriteChanges });\r\n  >     // assume em1 is a preexisting EntityManager\r\n  >     em1.setProperties( { queryOptions: newQo });\r\n  Any QueryOptions property that is not defined will be defaulted from any QueryOptions defined at a higher level in the breeze hierarchy, i.e.\r\n  -  from query.queryOptions\r\n  -  to   entityManager.queryOptions\r\n  -  to   QueryOptions.defaultInstance;\r\n\r\n  @param config - A configuration object.\r\n  **/\r\n  constructor(config?: QueryOptionsConfig) {\r\n    QueryOptions._updateWithConfig(this, config);\r\n  }\r\n\r\n  static resolve(queryOptionsArray: any[]) {\r\n    return new QueryOptions(core.resolveProperties(queryOptionsArray, [\"fetchStrategy\", \"mergeStrategy\", \"includeDeleted\"]));\r\n  }\r\n\r\n  /**\r\n  Returns a copy of this QueryOptions with the specified [[MergeStrategy]],\r\n  [[FetchStrategy]], or 'includeDeleted' option applied.\r\n  >     // Given an EntityManager instance, em\r\n  >     var queryOptions = em.queryOptions.using(MergeStrategy.PreserveChanges);\r\n\r\n  or\r\n  >     var queryOptions = em.queryOptions.using(FetchStrategy.FromLocalCache);\r\n\r\n  or\r\n  >     var queryOptions = em.queryOptions.using({ mergeStrategy: MergeStrategy.OverwriteChanges });\r\n\r\n  or\r\n  >     var queryOptions = em.queryOptions.using({\r\n  >        includeDeleted: true,\r\n  >        fetchStrategy:  FetchStrategy.FromLocalCache \r\n  >     });\r\n  @param config - A configuration object or a standalone [[MergeStrategy]] or [[FetchStrategy]] \r\n  @return A new QueryOptions instance.\r\n  **/\r\n  using(qoConfig: QueryOptionsConfig | MergeStrategy | FetchStrategy) {\r\n    if (!qoConfig) return this;\r\n    let result = new QueryOptions(this);\r\n    if ( qoConfig instanceof MergeStrategy) {\r\n      qoConfig = { mergeStrategy: qoConfig };\r\n    } else if ( qoConfig instanceof FetchStrategy) {\r\n      qoConfig = { fetchStrategy: qoConfig };\r\n    }\r\n    return QueryOptions._updateWithConfig(result, qoConfig);\r\n  }\r\n\r\n  /**\r\n  Sets the 'defaultInstance' by creating a copy of the current 'defaultInstance' and then applying all of the properties of the current instance.\r\n  The current instance is returned unchanged.\r\n  >     var newQo = new QueryOptions( { mergeStrategy: MergeStrategy.OverwriteChanges });\r\n  >     newQo.setAsDefault();\r\n  **/\r\n  setAsDefault() {\r\n    return core.setAsDefault(this, QueryOptions);\r\n  }\r\n\r\n  toJSON() {\r\n    return core.toJson(this, {\r\n      fetchStrategy: null,\r\n      mergeStrategy: null,\r\n      includeDeleted: false\r\n    });\r\n  }\r\n\r\n  static fromJSON(json: any) {\r\n    return new QueryOptions({\r\n      fetchStrategy: FetchStrategy.fromName(json.fetchStrategy),\r\n      mergeStrategy: MergeStrategy.fromName(json.mergeStrategy),\r\n      includeDeleted: json.includeDeleted === true\r\n    });\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  private static _updateWithConfig(obj: QueryOptions, config?: QueryOptionsConfig) {\r\n    if (config) {\r\n      assertConfig(config)\r\n        .whereParam(\"fetchStrategy\").isEnumOf(FetchStrategy).isOptional()\r\n        .whereParam(\"mergeStrategy\").isEnumOf(MergeStrategy).isOptional()\r\n        .whereParam(\"includeDeleted\").isBoolean().isOptional()\r\n        .applyAll(obj);\r\n    }\r\n    return obj;\r\n  }\r\n\r\n}\r\nQueryOptions.prototype._$typeName = \"QueryOptions\";\r\n"]}

package/esm2022/src/relation-array.mjs

@@ -0,0 +1,173 @@
+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"]}

package/esm2022/src/save-options.mjs

@@ -0,0 +1,51 @@
+import { core } from './core';
+import { assertConfig } from './assert-param';
+import { DataService } from './data-service';
+/**
+A SaveOptions instance is used to specify the 'options' under which a save will occur.
+**/
+export class SaveOptions {
+    /** @hidden @internal */
+    _$typeName; // on proto
+    /** Resource name to be used during the save - this defaults to "SaveChanges". __Read Only__ */
+    resourceName;
+    /** The DataService to be used for this save. __Read Only__ */
+    dataService;
+    /** Whether multiple saves can be in-flight at the same time. The default is false. __Read Only__ */
+    allowConcurrentSaves;
+    /** Free form value that will be sent to the server during the save. __Read Only__ */
+    tag;
+    /** The default value whenever SaveOptions are not specified. */
+    static defaultInstance = new SaveOptions({ allowConcurrentSaves: false });
+    constructor(config) {
+        SaveOptions._updateWithConfig(this, config);
+    }
+    /**
+    Sets the 'defaultInstance' by creating a copy of the current 'defaultInstance' and then applying all of the properties of the current instance.
+    The current instance is returned unchanged.
+    **/
+    setAsDefault() {
+        return core.setAsDefault(this, SaveOptions);
+    }
+    /**
+    Returns a copy of this SaveOptions with the specified config options applied.
+    >     var saveOptions = em1.saveOptions.using( {resourceName: "anotherResource" });
+    **/
+    using(config) {
+        return SaveOptions._updateWithConfig(this, config);
+    }
+    /** @hidden @internal */
+    static _updateWithConfig(obj, config) {
+        if (config) {
+            assertConfig(config)
+                .whereParam("resourceName").isOptional().isString()
+                .whereParam("dataService").isOptional().isInstanceOf(DataService)
+                .whereParam("allowConcurrentSaves").isBoolean().isOptional()
+                .whereParam("tag").isOptional()
+                .applyAll(obj);
+        }
+        return obj;
+    }
+}
+SaveOptions.prototype._$typeName = "SaveOptions";
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/unattached-children-map.mjs

@@ -0,0 +1,56 @@
+import { core } from './core';
+/** @hidden @internal */
+// Represents entities not yet attached to navigationProperties. 
+export class UnattachedChildrenMap {
+    // key is EntityKey.toString(), value is array of { navigationProperty, children }
+    map = {};
+    addChild(parentEntityKey, navigationProperty, child) {
+        let tuple = this.getTuple(parentEntityKey, navigationProperty);
+        if (!tuple) {
+            tuple = { navigationProperty: navigationProperty, children: [] };
+            core.getArray(this.map, parentEntityKey.toString()).push(tuple);
+        }
+        tuple.children.push(child);
+    }
+    removeChildren(parentEntityKeyString, navigationProperty) {
+        let tuples = this.map[parentEntityKeyString];
+        if (!tuples)
+            return;
+        core.arrayRemoveItem(tuples, (t) => {
+            return t.navigationProperty === navigationProperty;
+        });
+        if (!tuples.length) {
+            delete this.map[parentEntityKeyString];
+        }
+    }
+    getTuple(parentEntityKey, navigationProperty) {
+        let tuples = this.getTuples(parentEntityKey);
+        if (!tuples)
+            return null;
+        let tuple = core.arrayFirst(tuples, function (t) {
+            return t.navigationProperty === navigationProperty;
+        });
+        return tuple;
+    }
+    getTuples(parentEntityKey) {
+        let allTuples = [];
+        let tuples = this.map[parentEntityKey.toString()];
+        if (tuples) {
+            allTuples = allTuples.concat(tuples);
+        }
+        let entityType = parentEntityKey.entityType;
+        while (entityType.baseEntityType) {
+            entityType = entityType.baseEntityType;
+            let baseKey = parentEntityKey.toString(entityType);
+            tuples = this.map[baseKey];
+            if (tuples) {
+                allTuples = allTuples.concat(tuples);
+            }
+        }
+        return (allTuples.length) ? allTuples : undefined;
+    }
+    getTuplesByString(parentEntityKeyString) {
+        return this.map[parentEntityKeyString];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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