breeze-client 2.1.5 → 2.1.6-mjs

package/esm2022/src/abstract-data-service-adapter.mjs

@@ -0,0 +1,294 @@
+import { core } from './core';
+import { config } from './config';
+import { JsonResultsAdapter } from './data-service';
+import { MetadataStore } from './entity-metadata';
+/** For use by breeze plugin authors only.  The class is used as the base class for most [[IDataServiceAdapter]] implementations
+@adapter (see [[IDataServiceAdapter]])
+@hidden
+*/
+export class AbstractDataServiceAdapter {
+    // TODO use interface
+    checkForRecomposition(interfaceInitializedArgs) {
+        if (interfaceInitializedArgs.interfaceName === "ajax" && interfaceInitializedArgs.isDefault) {
+            this.initialize();
+        }
+    }
+    initialize() {
+        this.ajaxImpl = config.getAdapterInstance("ajax");
+        // don't cache 'ajax' because then we would need to ".bind" it, and don't want to because of brower support issues.
+        if (this.ajaxImpl && this.ajaxImpl.ajax) {
+            return;
+        }
+        throw new Error("Unable to find ajax adapter for dataservice adapter '" + (this.name || '') + "'.");
+    }
+    fetchMetadata(metadataStore, dataService) {
+        let serviceName = dataService.serviceName;
+        let url = dataService.qualifyUrl("Metadata");
+        let promise = new Promise((resolve, reject) => {
+            this.ajaxImpl.ajax({
+                type: "GET",
+                url: url,
+                dataType: 'json',
+                success: (httpResponse) => {
+                    // might have been fetched by another query
+                    if (metadataStore.hasMetadataFor(serviceName)) {
+                        return resolve("already fetched");
+                    }
+                    let data = httpResponse.data;
+                    let metadata;
+                    try {
+                        metadata = typeof (data) === "string" ? JSON.parse(data) : data;
+                        metadataStore.importMetadata(metadata);
+                    }
+                    catch (e) {
+                        let errMsg = "Unable to either parse or import metadata: " + e.message;
+                        handleHttpError(reject, httpResponse, "Metadata query failed for: " + url + ". " + errMsg);
+                    }
+                    // import may have brought in the service.
+                    if (!metadataStore.hasMetadataFor(serviceName)) {
+                        metadataStore.addDataService(dataService);
+                    }
+                    resolve(metadata);
+                },
+                error: (httpResponse) => {
+                    handleHttpError(reject, httpResponse, "Metadata query failed for: " + url);
+                }
+            });
+        });
+        return promise;
+    }
+    executeQuery(mappingContext) {
+        mappingContext.adapter = this;
+        let promise = new Promise((resolve, reject) => {
+            let url = mappingContext.getUrl();
+            let params = {
+                type: "GET",
+                url: url,
+                params: mappingContext.query.parameters,
+                dataType: 'json',
+                success: function (httpResponse) {
+                    let data = httpResponse.data;
+                    try {
+                        let rData;
+                        let results = data && (data.results || data.Results);
+                        if (results) {
+                            rData = { results: results, inlineCount: data.inlineCount || data.InlineCount,
+                                httpResponse: httpResponse, query: mappingContext.query };
+                        }
+                        else {
+                            rData = { results: data, httpResponse: httpResponse, query: mappingContext.query };
+                        }
+                        resolve(rData);
+                    }
+                    catch (e) {
+                        if (e instanceof Error) {
+                            reject(e);
+                        }
+                        else {
+                            handleHttpError(reject, httpResponse);
+                        }
+                    }
+                },
+                error: function (httpResponse) {
+                    handleHttpError(reject, httpResponse);
+                },
+                crossDomain: false
+            };
+            if (mappingContext.dataService.useJsonp) {
+                params.dataType = 'jsonp';
+                params.crossDomain = true;
+            }
+            this.ajaxImpl.ajax(params);
+        });
+        return promise;
+    }
+    saveChanges(saveContext, saveBundle) {
+        let adapter = saveContext.adapter = this;
+        let saveBundleSer = adapter._prepareSaveBundle(saveContext, saveBundle);
+        let bundle = JSON.stringify(saveBundleSer);
+        let url = saveContext.dataService.qualifyUrl(saveContext.resourceName);
+        let promise = new Promise((resolve, reject) => {
+            this.ajaxImpl.ajax({
+                type: "POST",
+                url: url,
+                dataType: 'json',
+                contentType: "application/json",
+                data: bundle,
+                success: function (httpResponse) {
+                    httpResponse.saveContext = saveContext;
+                    let data = httpResponse.data;
+                    if (data.Errors || data.errors) {
+                        handleHttpError(reject, httpResponse);
+                    }
+                    else {
+                        let saveResult = adapter._prepareSaveResult(saveContext, data);
+                        saveResult.httpResponse = httpResponse;
+                        resolve(saveResult);
+                    }
+                },
+                error: function (httpResponse) {
+                    httpResponse.saveContext = saveContext;
+                    handleHttpError(reject, httpResponse);
+                }
+            });
+        });
+        return promise;
+    }
+    /** Abstract method that needs to be overwritten in any concrete DataServiceAdapter subclass.
+    The return value from this method should be a serializable object that will be sent to the server after calling JSON.stringify on it.
+    */
+    _prepareSaveBundle(saveContext, saveBundle) {
+        // The implementor should call _createChangeRequestInterceptor
+        throw new Error("Need a concrete implementation of _prepareSaveBundle");
+    }
+    /**
+    Returns a constructor function for a "ChangeRequestInterceptor"
+    that can tweak the saveBundle both as it is built and when it is completed
+    by a concrete DataServiceAdapater.
+  
+    Initialized with a default, no-op implementation that developers can replace with a
+    substantive implementation that changes the individual entity change requests
+    or aspects of the entire 'saveBundle' without having to write their own DataService adapters.
+    >     let adapter = breeze.config.getAdapterInstance('dataService');
+    >     adapter.changeRequestInterceptor = function (saveContext, saveBundle) {
+    >         this.getRequest = function (request, entity, index) {
+    >            // alter the request that the adapter prepared for this entity
+    >            // based on the entity, saveContext, and saveBundle
+    >            // e.g., add a custom header or prune the originalValuesMap
+    >            return request;
+    >        };
+    >        this.done = function (requests) {
+    >            // alter the array of requests representing the entire change-set
+    >            // based on the saveContext and saveBundle
+    >        };
+    >     }
+  
+    @param saveContext - The BreezeJS "context" for the save operation.
+    @param saveBundle - Contains the array of entities-to-be-saved (AKA, the entity change-set).
+    @return Constructor for a "ChangeRequestInterceptor".
+    **/
+    changeRequestInterceptor = DefaultChangeRequestInterceptor;
+    /** @hidden @internal */
+    _createChangeRequestInterceptor(saveContext, saveBundle) {
+        let adapter = saveContext.adapter;
+        let cri = adapter.changeRequestInterceptor;
+        let isFn = core.isFunction;
+        if (isFn(cri)) {
+            let pre = adapter.name + " DataServiceAdapter's ChangeRequestInterceptor";
+            let post = " is missing or not a function.";
+            let interceptor = new cri(saveContext, saveBundle);
+            if (!isFn(interceptor.getRequest)) {
+                throw new Error(pre + '.getRequest' + post);
+            }
+            if (!isFn(interceptor.done)) {
+                throw new Error(pre + '.done' + post);
+            }
+            return interceptor;
+        }
+        else {
+            return new DefaultChangeRequestInterceptor(saveContext, saveBundle);
+        }
+    }
+    /** Abstract method that needs to be overwritten in any concrete DataServiceAdapter sublclass.
+    This method needs to take the result returned the server and convert it into an ISaveResult.
+    */
+    _prepareSaveResult(saveContext, data) {
+        throw new Error("Need a concrete implementation of _prepareSaveResult");
+    }
+    /** Utility method that may be used in any concrete DataServiceAdapter sublclass to handle any
+    http connection issues.
+    */
+    // Put this at the bottom of your http error analysis
+    static _catchNoConnectionError(err) {
+        if (err.status === 0 && err.message == null) {
+            err.message = "HTTP response status 0 and no message.  " +
+                "Likely did not or could not reach server. Is the server running?";
+        }
+    }
+    jsonResultsAdapter = new JsonResultsAdapter({
+        name: "noop",
+        visitNode: function ( /* node, mappingContext, nodeContext */) {
+            return {};
+        }
+    });
+}
+function handleHttpError(reject, httpResponse, messagePrefix) {
+    let err = createError(httpResponse);
+    AbstractDataServiceAdapter._catchNoConnectionError(err);
+    if (messagePrefix) {
+        err.message = messagePrefix + "; " + err.message;
+    }
+    reject(err);
+}
+function createError(httpResponse) {
+    let err = new Error();
+    err.httpResponse = httpResponse;
+    err.status = httpResponse.status;
+    let errObj = httpResponse.data;
+    if (!errObj) {
+        err.message = httpResponse.error && httpResponse.error.toString();
+        return err;
+    }
+    // some ajax providers will convert errant result into an object (angularjs), others will not (jQuery)
+    // if not do it here.
+    if (typeof errObj === "string") {
+        try {
+            errObj = JSON.parse(errObj);
+        }
+        catch (e) {
+            // sometimes httpResponse.data is just the error message itself
+            err.message = errObj;
+            return err;
+        }
+    }
+    let saveContext = httpResponse.saveContext;
+    // if any of the follow properties exist the source is .NET
+    let tmp = errObj.Message || errObj.ExceptionMessage || errObj.EntityErrors || errObj.Errors;
+    let isDotNet = !!tmp;
+    let message, entityErrors;
+    if (!isDotNet) {
+        message = errObj.message;
+        entityErrors = errObj.errors || errObj.entityErrors;
+    }
+    else {
+        let tmp = errObj;
+        do {
+            // .NET exceptions can provide both ExceptionMessage and Message but ExceptionMethod if it
+            // exists has a more detailed message.
+            message = tmp.ExceptionMessage || tmp.Message;
+            tmp = tmp.InnerException;
+        } while (tmp);
+        // .EntityErrors will only occur as a result of an EntityErrorsException being deliberately thrown on the server
+        entityErrors = errObj.Errors || errObj.EntityErrors;
+        entityErrors = entityErrors && entityErrors.map(function (e) {
+            return {
+                errorName: e.ErrorName,
+                entityTypeName: MetadataStore.normalizeTypeName(e.EntityTypeName),
+                keyValues: e.KeyValues,
+                propertyName: e.PropertyName,
+                errorMessage: e.ErrorMessage,
+                custom: e.Custom
+            };
+        });
+    }
+    if (saveContext && entityErrors) {
+        let propNameFn = saveContext.entityManager.metadataStore.namingConvention.serverPropertyNameToClient;
+        entityErrors.forEach(function (e) {
+            e.propertyName = e.propertyName && propNameFn(e.propertyName);
+        });
+        err.entityErrors = entityErrors;
+    }
+    err.message = message || "Server side errors encountered - see the entityErrors collection on this object for more detail";
+    return err;
+}
+/** This is a default, no-op implementation that developers can replace. */
+class DefaultChangeRequestInterceptor {
+    constructor(saveContext, saveBundle) {
+    }
+    getRequest(request, entity, index) {
+        return request;
+    }
+    done(requests) {
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstract-data-service-adapter.js","sourceRoot":"","sources":["../../../src/abstract-data-service-adapter.ts"],"names":[],"mappings":"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","sourcesContent":["import { core } from './core';\r\nimport { config } from './config';\r\nimport { EntityQuery } from './entity-query';\r\nimport { DataServiceAdapter, AjaxAdapter, ChangeRequestInterceptorCtor, ChangeRequestInterceptor } from './interface-registry';\r\nimport { Entity } from './entity-aspect';\r\nimport { MappingContext } from './mapping-context';\r\nimport { DataService, JsonResultsAdapter } from './data-service';\r\nimport { HttpResponse, SaveContext, SaveBundle, ServerError, SaveResult, SaveErrorFromServer, QueryResult } from './entity-manager';\r\nimport { MetadataStore } from './entity-metadata';\r\n\r\n/** For use by breeze plugin authors only.  The class is used as the base class for most [[IDataServiceAdapter]] implementations\r\n@adapter (see [[IDataServiceAdapter]])    \r\n@hidden\r\n*/\r\nexport abstract class AbstractDataServiceAdapter implements DataServiceAdapter {\r\n  /** @hidden @internal */\r\n  declare _$impl?: any;\r\n  /** The name of this adapter. */\r\n  declare name: string;\r\n  /** The [[IAjaxAdapter]] used by this [[IDataServiceAdapter]]. */\r\n  declare ajaxImpl: AjaxAdapter;\r\n\r\n  // TODO use interface\r\n  checkForRecomposition(interfaceInitializedArgs: any) {\r\n    if (interfaceInitializedArgs.interfaceName === \"ajax\" && interfaceInitializedArgs.isDefault) {\r\n      this.initialize();\r\n    }\r\n  }\r\n\r\n  initialize() {\r\n    this.ajaxImpl = config.getAdapterInstance<AjaxAdapter>(\"ajax\") !;\r\n\r\n    // don't cache 'ajax' because then we would need to \".bind\" it, and don't want to because of brower support issues.\r\n    if (this.ajaxImpl && this.ajaxImpl.ajax) {\r\n      return;\r\n    }\r\n    throw new Error(\"Unable to find ajax adapter for dataservice adapter '\" + (this.name || '') + \"'.\");\r\n  }\r\n\r\n  fetchMetadata(metadataStore: MetadataStore, dataService: DataService) {\r\n    let serviceName = dataService.serviceName;\r\n    let url = dataService.qualifyUrl(\"Metadata\");\r\n\r\n    let promise = new Promise((resolve, reject) => {\r\n\r\n      this.ajaxImpl.ajax({\r\n        type: \"GET\",\r\n        url: url,\r\n        dataType: 'json',\r\n        success: (httpResponse: HttpResponse) => {\r\n\r\n          // might have been fetched by another query\r\n          if (metadataStore.hasMetadataFor(serviceName)) {\r\n            return resolve(\"already fetched\");\r\n          }\r\n          let data = httpResponse.data;\r\n          let metadata: any;\r\n          try {\r\n            metadata = typeof (data) === \"string\" ? JSON.parse(data) : data;\r\n            metadataStore.importMetadata(metadata);\r\n          } catch (e) {\r\n            let errMsg = \"Unable to either parse or import metadata: \" + e.message;\r\n            handleHttpError(reject, httpResponse, \"Metadata query failed for: \" + url + \". \" + errMsg);\r\n          }\r\n\r\n          // import may have brought in the service.\r\n          if (!metadataStore.hasMetadataFor(serviceName)) {\r\n            metadataStore.addDataService(dataService);\r\n          }\r\n\r\n          resolve(metadata);\r\n\r\n        },\r\n        error: (httpResponse: HttpResponse) => {\r\n          handleHttpError(reject, httpResponse, \"Metadata query failed for: \" + url);\r\n        }\r\n      });\r\n    });\r\n    return promise;\r\n  }\r\n\r\n  executeQuery(mappingContext: MappingContext) {\r\n    mappingContext.adapter = this;\r\n    let promise = new Promise<QueryResult>((resolve, reject) => {\r\n      let url = mappingContext.getUrl();\r\n\r\n      let params = {\r\n        type: \"GET\",\r\n        url: url,\r\n        params: (mappingContext.query as EntityQuery).parameters,\r\n        dataType: 'json',\r\n        success: function (httpResponse: HttpResponse) {\r\n          let data = httpResponse.data;\r\n          try {\r\n            let rData: QueryResult;\r\n            let results = data && (data.results || data.Results);\r\n            if (results) {\r\n              rData = { results: results, inlineCount: data.inlineCount || data.InlineCount, \r\n                httpResponse: httpResponse, query: mappingContext.query };\r\n            } else {\r\n              rData = { results: data, httpResponse: httpResponse, query: mappingContext.query };\r\n            }\r\n\r\n            resolve(rData);\r\n          } catch (e) {\r\n            if (e instanceof Error) {\r\n              reject(e);\r\n            } else {\r\n              handleHttpError(reject, httpResponse);\r\n            }\r\n          }\r\n\r\n        },\r\n        error: function (httpResponse: HttpResponse) {\r\n          handleHttpError(reject, httpResponse);\r\n        },\r\n        crossDomain: false\r\n      };\r\n      if (mappingContext.dataService.useJsonp) {\r\n        params.dataType = 'jsonp';\r\n        params.crossDomain = true;\r\n      }\r\n      this.ajaxImpl.ajax(params);\r\n    });\r\n    return promise;\r\n  }\r\n\r\n  saveChanges(saveContext: SaveContext, saveBundle: SaveBundle) {\r\n    let adapter = saveContext.adapter = this;\r\n\r\n    let saveBundleSer = adapter._prepareSaveBundle(saveContext, saveBundle);\r\n    let bundle = JSON.stringify(saveBundleSer);\r\n\r\n    let url = saveContext.dataService.qualifyUrl(saveContext.resourceName);\r\n    let promise = new Promise<SaveResult>((resolve, reject) => {\r\n      this.ajaxImpl.ajax({\r\n        type: \"POST\",\r\n        url: url,\r\n        dataType: 'json',\r\n        contentType: \"application/json\",\r\n        data: bundle,\r\n        success: function (httpResponse: HttpResponse) {\r\n          httpResponse.saveContext = saveContext;\r\n          let data = httpResponse.data;\r\n          if (data.Errors || data.errors) {\r\n            handleHttpError(reject, httpResponse);\r\n          } else {\r\n            let saveResult = adapter._prepareSaveResult(saveContext, data);\r\n            saveResult.httpResponse = httpResponse;\r\n            resolve(saveResult);\r\n          }\r\n        },\r\n        error: function (httpResponse: HttpResponse) {\r\n          httpResponse.saveContext = saveContext;\r\n          handleHttpError(reject, httpResponse);\r\n        }\r\n      });\r\n    });\r\n\r\n    return promise;\r\n  }\r\n\r\n  /** Abstract method that needs to be overwritten in any concrete DataServiceAdapter subclass. \r\n  The return value from this method should be a serializable object that will be sent to the server after calling JSON.stringify on it.\r\n  */\r\n  _prepareSaveBundle(saveContext: SaveContext, saveBundle: SaveBundle): any {\r\n    // The implementor should call _createChangeRequestInterceptor\r\n    throw new Error(\"Need a concrete implementation of _prepareSaveBundle\");\r\n  }\r\n\r\n  /**\r\n  Returns a constructor function for a \"ChangeRequestInterceptor\"\r\n  that can tweak the saveBundle both as it is built and when it is completed\r\n  by a concrete DataServiceAdapater.\r\n\r\n  Initialized with a default, no-op implementation that developers can replace with a\r\n  substantive implementation that changes the individual entity change requests\r\n  or aspects of the entire 'saveBundle' without having to write their own DataService adapters.\r\n  >     let adapter = breeze.config.getAdapterInstance('dataService');\r\n  >     adapter.changeRequestInterceptor = function (saveContext, saveBundle) {\r\n  >         this.getRequest = function (request, entity, index) {\r\n  >            // alter the request that the adapter prepared for this entity\r\n  >            // based on the entity, saveContext, and saveBundle\r\n  >            // e.g., add a custom header or prune the originalValuesMap\r\n  >            return request;\r\n  >        };\r\n  >        this.done = function (requests) {\r\n  >            // alter the array of requests representing the entire change-set\r\n  >            // based on the saveContext and saveBundle\r\n  >        };\r\n  >     }\r\n\r\n  @param saveContext - The BreezeJS \"context\" for the save operation.\r\n  @param saveBundle - Contains the array of entities-to-be-saved (AKA, the entity change-set).\r\n  @return Constructor for a \"ChangeRequestInterceptor\".\r\n  **/\r\n  changeRequestInterceptor: ChangeRequestInterceptorCtor = DefaultChangeRequestInterceptor;\r\n\r\n  /** @hidden @internal */\r\n  _createChangeRequestInterceptor(saveContext: SaveContext, saveBundle: SaveBundle) {\r\n    let adapter = saveContext.adapter!;\r\n    let cri = adapter.changeRequestInterceptor;\r\n    let isFn = core.isFunction;\r\n\r\n    if (isFn(cri)) {\r\n      let pre = adapter.name + \" DataServiceAdapter's ChangeRequestInterceptor\";\r\n      let post = \" is missing or not a function.\";\r\n      let interceptor = new cri(saveContext, saveBundle);\r\n      if (!isFn(interceptor.getRequest)) {\r\n        throw new Error(pre + '.getRequest' + post);\r\n      }\r\n      if (!isFn(interceptor.done)) {\r\n        throw new Error(pre + '.done' + post);\r\n      }\r\n      return interceptor;\r\n    } else {\r\n      return new DefaultChangeRequestInterceptor(saveContext, saveBundle) as ChangeRequestInterceptor;\r\n    }\r\n  }\r\n\r\n  /** Abstract method that needs to be overwritten in any concrete DataServiceAdapter sublclass. \r\n  This method needs to take the result returned the server and convert it into an ISaveResult. \r\n  */\r\n  _prepareSaveResult(saveContext: SaveContext, data: any): SaveResult {\r\n    throw new Error(\"Need a concrete implementation of _prepareSaveResult\");\r\n  }\r\n\r\n\r\n  /** Utility method that may be used in any concrete DataServiceAdapter sublclass to handle any \r\n  http connection issues. \r\n  */\r\n  // Put this at the bottom of your http error analysis\r\n  static _catchNoConnectionError(err: ServerError) {\r\n    if (err.status === 0 && err.message == null) {\r\n      err.message = \"HTTP response status 0 and no message.  \" +\r\n        \"Likely did not or could not reach server. Is the server running?\";\r\n    }\r\n  }\r\n\r\n  jsonResultsAdapter = new JsonResultsAdapter({\r\n    name: \"noop\",\r\n\r\n    visitNode: function (/* node, mappingContext, nodeContext */) {\r\n      return {};\r\n    }\r\n  });\r\n}\r\n\r\nfunction handleHttpError(reject: (reason?: any) => void, httpResponse: HttpResponse, messagePrefix?: string) {\r\n  let err = createError(httpResponse);\r\n  AbstractDataServiceAdapter._catchNoConnectionError(err);\r\n  if (messagePrefix) {\r\n    err.message = messagePrefix + \"; \" + err.message;\r\n  }\r\n  reject(err);\r\n}\r\n\r\nfunction createError(httpResponse: HttpResponse) {\r\n  let err = new Error() as ServerError;\r\n  err.httpResponse = httpResponse;\r\n  err.status = httpResponse.status;\r\n\r\n  let errObj = httpResponse.data;\r\n\r\n  if (!errObj) {\r\n    err.message = httpResponse.error && httpResponse.error.toString();\r\n    return err;\r\n  }\r\n\r\n  // some ajax providers will convert errant result into an object (angularjs), others will not (jQuery)\r\n  // if not do it here.\r\n  if (typeof errObj === \"string\") {\r\n    try {\r\n      errObj = JSON.parse(errObj);\r\n    } catch (e) {\r\n      // sometimes httpResponse.data is just the error message itself\r\n      err.message = errObj;\r\n      return err;\r\n    }\r\n  }\r\n\r\n  let saveContext = httpResponse.saveContext;\r\n\r\n  // if any of the follow properties exist the source is .NET\r\n  let tmp = errObj.Message || errObj.ExceptionMessage || errObj.EntityErrors || errObj.Errors;\r\n  let isDotNet = !!tmp;\r\n  let message: string, entityErrors: any[];\r\n  if (!isDotNet) {\r\n    message = errObj.message;\r\n    entityErrors = errObj.errors || errObj.entityErrors;\r\n  } else {\r\n    let tmp = errObj;\r\n    do {\r\n      // .NET exceptions can provide both ExceptionMessage and Message but ExceptionMethod if it\r\n      // exists has a more detailed message.\r\n      message = tmp.ExceptionMessage || tmp.Message;\r\n      tmp = tmp.InnerException;\r\n    } while (tmp);\r\n    // .EntityErrors will only occur as a result of an EntityErrorsException being deliberately thrown on the server\r\n    entityErrors = errObj.Errors || errObj.EntityErrors;\r\n    entityErrors = entityErrors && entityErrors.map(function (e) {\r\n      return {\r\n        errorName: e.ErrorName,\r\n        entityTypeName: MetadataStore.normalizeTypeName(e.EntityTypeName),\r\n        keyValues: e.KeyValues,\r\n        propertyName: e.PropertyName,\r\n        errorMessage: e.ErrorMessage,\r\n        custom: e.Custom\r\n      };\r\n    });\r\n  }\r\n\r\n  if (saveContext && entityErrors) {\r\n\r\n    let propNameFn = saveContext.entityManager.metadataStore.namingConvention.serverPropertyNameToClient;\r\n    entityErrors.forEach(function (e) {\r\n      e.propertyName = e.propertyName && propNameFn(e.propertyName);\r\n    });\r\n    (err as SaveErrorFromServer).entityErrors = entityErrors;\r\n  }\r\n\r\n  err.message = message || \"Server side errors encountered - see the entityErrors collection on this object for more detail\";\r\n  return err;\r\n}\r\n\r\n\r\n/** This is a default, no-op implementation that developers can replace. */\r\nclass DefaultChangeRequestInterceptor {\r\n  constructor(saveContext: SaveContext, saveBundle: SaveBundle) {\r\n\r\n  }\r\n\r\n  getRequest(request: any, entity: Entity, index: number) {\r\n    return request;\r\n  }\r\n\r\n  done(requests: Object[]) {\r\n  }\r\n}\r\n"]}

package/esm2022/src/array.mjs

@@ -0,0 +1,4 @@
+export { makeRelationArray } from './relation-array';
+export { makeComplexArray } from './complex-array';
+export { makePrimitiveArray } from './primitive-array';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXJyYXkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXJyYXkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDckQsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDbkQsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sbUJBQW1CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBtYWtlUmVsYXRpb25BcnJheSB9IGZyb20gJy4vcmVsYXRpb24tYXJyYXknO1xyXG5leHBvcnQgeyBtYWtlQ29tcGxleEFycmF5IH0gZnJvbSAnLi9jb21wbGV4LWFycmF5JztcclxuZXhwb3J0IHsgbWFrZVByaW1pdGl2ZUFycmF5IH0gZnJvbSAnLi9wcmltaXRpdmUtYXJyYXknO1xyXG4iXX0=