breeze-client
Version:
Breeze data management for JavaScript clients
325 lines (323 loc) • 46.4 kB
JavaScript
import { core } from './core';
import { config } from './config';
import { JsonResultsAdapter } from './data-service';
import { EntityType, 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;
}
/** Execute the query in the mappingContext using the ajaxImpl. */
executeQuery(mappingContext) {
mappingContext.adapter = this;
const usePost = mappingContext.query.usePostEnabled;
const params = usePost ? this._makeQueryPostParams(mappingContext) : this._makeQueryGetParams(mappingContext);
let promise = new Promise((resolve, reject) => {
params.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);
}
}
};
params.error = function (httpResponse) {
handleHttpError(reject, httpResponse);
};
this.ajaxImpl.ajax(params);
});
return promise;
}
/** Set up ajax parameters for query GET. This puts the query into the request querystring in either JSON or OData-style syntax, depending upon the UriBuilder. */
_makeQueryGetParams(mappingContext) {
const url = mappingContext.getUrl();
const params = {
type: "GET",
url: url,
params: mappingContext.query.parameters,
dataType: 'json',
crossDomain: false,
};
if (mappingContext.dataService.useJsonp) {
params.dataType = 'jsonp';
params.crossDomain = true;
}
return params;
}
/** Set up ajax parameters for query POST. This put the query into the request body as JSON. */
_makeQueryPostParams(mappingContext) {
const entityQuery = mappingContext.query;
const metadataStore = mappingContext.entityManager.metadataStore;
const url = mappingContext.dataService.qualifyUrl(entityQuery.resourceName);
let entityType = entityQuery._getFromEntityType(metadataStore, false);
if (!entityType) {
entityType = new EntityType(metadataStore);
}
const json = entityQuery.toJSONExt({ entityType: entityType, toNameOnServer: true });
json.from = undefined;
json.queryOptions = undefined;
const params = {
type: "POST",
url: url,
params: mappingContext.query.parameters,
dataType: 'json',
processData: false,
contentType: "application/json; charset=UTF-8",
data: JSON.stringify(json),
crossDomain: false,
};
return params;
}
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 { EntityType, 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  /** Execute the query in the mappingContext using the ajaxImpl. */\r\n  executeQuery(mappingContext: MappingContext) {\r\n    mappingContext.adapter = this;\r\n\r\n    const usePost = (mappingContext.query as EntityQuery).usePostEnabled;\r\n    const params = usePost ? this._makeQueryPostParams(mappingContext) : this._makeQueryGetParams(mappingContext) as any;\r\n\r\n    let promise = new Promise<QueryResult>((resolve, reject) => {\r\n      params.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      params.error = function (httpResponse: HttpResponse) {\r\n        handleHttpError(reject, httpResponse);\r\n      };\r\n      this.ajaxImpl.ajax(params);\r\n    });\r\n    return promise;\r\n  }\r\n\r\n  /** Set up ajax parameters for query GET.  This puts the query into the request querystring in either JSON or OData-style syntax, depending upon the UriBuilder. */\r\n  _makeQueryGetParams(mappingContext: MappingContext) {\r\n    const url = mappingContext.getUrl();\r\n\r\n    const params = {\r\n      type: \"GET\",\r\n      url: url,\r\n      params: (mappingContext.query as EntityQuery).parameters,\r\n      dataType: 'json',\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    return params;\r\n  }\r\n\r\n  /** Set up ajax parameters for query POST.  This put the query into the request body as JSON. */\r\n  _makeQueryPostParams(mappingContext: MappingContext) {\r\n    const entityQuery = mappingContext.query as EntityQuery;\r\n    const metadataStore = mappingContext.entityManager.metadataStore;\r\n    const url = mappingContext.dataService.qualifyUrl(entityQuery.resourceName);\r\n\r\n    let entityType = entityQuery._getFromEntityType(metadataStore, false);\r\n    if (!entityType) { entityType = new EntityType(metadataStore); }\r\n    const json = entityQuery.toJSONExt({ entityType: entityType, toNameOnServer: true}) as any;\r\n    json.from = undefined;\r\n    json.queryOptions = undefined;\r\n\r\n    const params = {\r\n      type: \"POST\",\r\n      url: url,\r\n      params: (mappingContext.query as EntityQuery).parameters,\r\n      dataType: 'json',\r\n      processData: false, // don't let JQuery form-encode it\r\n      contentType: \"application/json; charset=UTF-8\",\r\n      data: JSON.stringify(json),\r\n      crossDomain: false,\r\n    };\r\n    return params;\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"]}