breeze-client 2.2.1-cjs → 2.2.2

package/esm2022/src/data-service.mjs

@@ -0,0 +1,221 @@
+import { assertConfig } from './assert-param';
+import { config } from './config';
+import { core } from './core';
+/**
+A DataService instance is used to encapsulate the details of a single 'service'; this includes a serviceName, a dataService adapterInstance,
+and whether the service has server side metadata.
+
+You can construct an EntityManager with either a serviceName or a DataService instance, if you use a serviceName then a DataService
+is constructed for you.  (It can also be set via the EntityManager.setProperties method).
+
+The same applies to the MetadataStore.fetchMetadata method, i.e. it takes either a serviceName or a DataService instance.
+
+Each metadataStore contains a list of DataServices, each accessible via its ‘serviceName’.
+( see MetadataStore.getDataService and MetadataStore.addDataService).  The ‘addDataService’ method is called internally
+anytime a MetadataStore.fetchMetadata call occurs with a new dataService ( or service name).
+
+**/
+export class DataService {
+    /**   DataService constructor
+    >     var dataService = new DataService({
+    >         serviceName: altServiceName,
+    >         hasServerMetadata: false
+    >     });
+  
+    >     var metadataStore = new MetadataStore({
+    >         namingConvention: NamingConvention.camelCase
+    >     });
+  
+    >     return new EntityManager({
+    >         dataService: dataService,
+    >         metadataStore: metadataStore
+    >     });
+    @param config - A configuration object.
+    **/
+    constructor(config) {
+        updateWithConfig(this, config);
+    }
+    /**
+    Returns a copy of this DataService with the specified properties applied.
+    @param config - The configuration object to apply to create a new DataService.
+    **/
+    using(config) {
+        if (!config)
+            return this;
+        let result = new DataService(this);
+        return updateWithConfig(result, config);
+    }
+    static resolve(dataServices) {
+        // final defaults
+        // Deliberate use of 'as any' below.
+        dataServices.push({
+            hasServerMetadata: true,
+            useJsonp: false
+        });
+        let ds = new DataService(core.resolveProperties(dataServices, ["serviceName", "adapterName", "uriBuilderName", "hasServerMetadata", "jsonResultsAdapter", "useJsonp"]));
+        if (!ds.serviceName) {
+            throw new Error("Unable to resolve a 'serviceName' for this dataService");
+        }
+        ds.adapterInstance = ds.adapterInstance || config.getAdapterInstance("dataService", ds.adapterName);
+        ds.jsonResultsAdapter = ds.jsonResultsAdapter || ds.adapterInstance.jsonResultsAdapter;
+        ds.uriBuilder = ds.uriBuilder || config.getAdapterInstance("uriBuilder", ds.uriBuilderName);
+        return ds;
+    }
+    /** @hidden @internal */
+    static _normalizeServiceName(serviceName) {
+        serviceName = serviceName.trim();
+        if (serviceName.substr(-1) !== "/") {
+            return serviceName + '/';
+        }
+        else {
+            return serviceName;
+        }
+    }
+    /**  */
+    toJSON() {
+        // don't use default value here - because we want to be able to distinguish undefined props for inheritence purposes.
+        return core.toJson(this, {
+            serviceName: null,
+            adapterName: null,
+            uriBuilderName: null,
+            hasServerMetadata: null,
+            jsonResultsAdapter: function (v) {
+                return v && v.name;
+            },
+            useJsonp: null
+        });
+    }
+    static fromJSON(json) {
+        json.jsonResultsAdapter = config._fetchObject(JsonResultsAdapter, json.jsonResultsAdapter);
+        return new DataService(json);
+    }
+    /**
+     Returns a url for this dataService with the specified suffix. This method handles dataService names either
+     with or without trailing '/'s.  If the suffix starts with "http" then it will be returned as-is.
+     @method qualifyUrl
+     @param suffix {String} The resulting url.
+     @return {a Url string}
+     **/
+    qualifyUrl(suffix) {
+        if (suffix && suffix.startsWith("http")) {
+            return suffix;
+        }
+        let url = this.serviceName;
+        // remove any trailing "/"
+        if (core.stringEndsWith(url, "/")) {
+            url = url.substr(0, url.length - 1);
+        }
+        // ensure that it ends with "/" + suffix
+        suffix = "/" + suffix;
+        if (!core.stringEndsWith(url, suffix)) {
+            url = url + suffix;
+        }
+        return url;
+    }
+}
+DataService.prototype._$typeName = "DataService";
+function updateWithConfig(obj, dsConfig) {
+    if (dsConfig) {
+        assertConfig(dsConfig)
+            .whereParam("serviceName").isOptional()
+            .whereParam("adapterName").isString().isOptional()
+            .whereParam("uriBuilderName").isString().isOptional()
+            .whereParam("hasServerMetadata").isBoolean().isOptional()
+            .whereParam("jsonResultsAdapter").isInstanceOf(JsonResultsAdapter).isOptional()
+            .whereParam("useJsonp").isBoolean().isOptional()
+            .applyAll(obj);
+        obj.serviceName = obj.serviceName && DataService._normalizeServiceName(obj.serviceName);
+        obj.adapterInstance = obj.adapterName ? config.getAdapterInstance("dataService", obj.adapterName) : undefined;
+        obj.uriBuilder = obj.uriBuilderName ? config.getAdapterInstance("uriBuilder", obj.uriBuilderName) : undefined;
+    }
+    return obj;
+}
+/**
+A JsonResultsAdapter instance is used to provide custom extraction and parsing logic on the json results returned by any web service.
+This facility makes it possible for breeze to talk to virtually any web service and return objects that will be first class 'breeze' citizens.
+**/
+export class JsonResultsAdapter {
+    /** @hidden @internal */
+    _$typeName; // actually put on prototype.
+    /** The name of this adapter.  This name is used to uniquely identify and locate this instance when an 'exported' JsonResultsAdapter is later imported. */
+    name;
+    /** A Function that is called once per query operation to extract the 'payload' from any json received over the wire.
+    This method has a default implementation which simply returns the "results" property from any json returned as a result of executing the query. */
+    extractResults; // TODO - refine
+    /** A function that is called once per save operation to extract the entities from any json received over the wire.  Must return an array.
+    This method has a default implementation which simply returns the "entities" property from any json returned as a result of executing the save. */
+    extractSaveResults;
+    /** A function that is called once per save operation to extract the key mappings from any json received over the wire.  Must return an array.
+  This method has a default implementation which simply returns the "keyMappings" property from any json returned as a result of executing the save. */
+    extractKeyMappings;
+    /** A function that is called once per save operation to extract any deleted keys from any json received over the wire.  Must return an array.
+    This method has a default implementation which is to simply returns the "deletedKeys" property from any json returned as a result of executing the save. */
+    extractDeletedKeys; // TODO: refine
+    /** A visitor method that will be called on each node of the returned payload. */
+    visitNode;
+    /**
+    JsonResultsAdapter constructor
+  
+    @example
+        //
+        var jsonResultsAdapter = new JsonResultsAdapter({
+            name: "test1e",
+            extractResults: function(json) {
+                return json.results;
+            },
+            visitNode: function(node, mappingContext, nodeContext) {
+                var entityType = normalizeTypeName(node.$type);
+                var propertyName = nodeContext.propertyName;
+                var ignore = propertyName && propertyName.substr(0, 1) === "$";
+  
+                return {
+                    entityType: entityType,
+                    nodeId: node.$id,
+                    nodeRefId: node.$ref,
+                    ignore: ignore,
+                    passThru: false // default
+                };
+            }
+        });
+  
+        var dataService = new DataService( {
+                serviceName: "breeze/foo",
+                jsonResultsAdapter: jsonResultsAdapter
+        });
+  
+        var entityManager = new EntityManager( {
+            dataService: dataService
+        });
+  
+    @param config - A configuration object.
+  
+    **/
+    constructor(jsConfig) {
+        if (arguments.length !== 1) {
+            throw new Error("The JsonResultsAdapter ctor should be called with a single argument that is a configuration object.");
+        }
+        assertConfig(jsConfig)
+            .whereParam("name").isNonEmptyString()
+            .whereParam("extractResults").isFunction().isOptional().withDefault(extractResultsDefault)
+            .whereParam("extractSaveResults").isFunction().isOptional().withDefault(extractSaveResultsDefault)
+            .whereParam("extractKeyMappings").isFunction().isOptional().withDefault(extractKeyMappingsDefault)
+            .whereParam("extractDeletedKeys").isFunction().isOptional().withDefault(extractDeletedKeysDefault)
+            .whereParam("visitNode").isFunction()
+            .applyAll(this);
+        config._storeObject(this, "JsonResultsAdapter", this.name);
+    }
+}
+JsonResultsAdapter.prototype._$typeName = "JsonResultsAdapter";
+function extractResultsDefault(data) {
+    return data.results;
+}
+function extractSaveResultsDefault(data) {
+    return data.entities || data.Entities || [];
+}
+function extractKeyMappingsDefault(data) {
+    return data.keyMappings || data.KeyMappings || [];
+}
+function extractDeletedKeysDefault(data) {
+    return data.deletedKeys || data.DeletedKeys || [];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-service.js","sourceRoot":"","sources":["../../../src/data-service.ts"],"names":[],"mappings":"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","sourcesContent":["import { EntityType, NavigationProperty } from './entity-metadata';\r\nimport { DataServiceAdapter, UriBuilderAdapter } from './interface-registry';\r\nimport { KeyMapping } from './entity-manager';\r\nimport { MappingContext } from './mapping-context';\r\nimport { assertConfig } from './assert-param';\r\nimport { config } from './config';\r\nimport { core } from './core';\r\n\r\n/** Configuration info to be passed to the [[DataService]] constructor */\r\nexport interface DataServiceConfig {\r\n  /** The serviceName for this DataService.  **/\r\n  serviceName?: string;\r\n  /** The adapter name for the [[IDataServiceAdapter]] to be used with this service.  **/\r\n  adapterName?: string;\r\n  /** The adapter name for the [[IUriBuilderAdapter]] to be used with this service.  **/\r\n  uriBuilderName?: string;\r\n  /** Whether the server can provide metadata for this service.  **/\r\n  hasServerMetadata?: boolean;\r\n  /** The [[JsonResultsAdapter]] used to process the results of any query against this DataService.  **/\r\n  jsonResultsAdapter?: JsonResultsAdapter;\r\n  /** Whether to use JSONP when performing a 'GET' request against this service.  **/\r\n  useJsonp?: boolean;\r\n}\r\n/**\r\nA DataService instance is used to encapsulate the details of a single 'service'; this includes a serviceName, a dataService adapterInstance,\r\nand whether the service has server side metadata.\r\n\r\nYou can construct an EntityManager with either a serviceName or a DataService instance, if you use a serviceName then a DataService\r\nis constructed for you.  (It can also be set via the EntityManager.setProperties method).\r\n\r\nThe same applies to the MetadataStore.fetchMetadata method, i.e. it takes either a serviceName or a DataService instance.\r\n\r\nEach metadataStore contains a list of DataServices, each accessible via its ‘serviceName’.\r\n( see MetadataStore.getDataService and MetadataStore.addDataService).  The ‘addDataService’ method is called internally\r\nanytime a MetadataStore.fetchMetadata call occurs with a new dataService ( or service name).\r\n\r\n**/\r\nexport class DataService {\r\n  /** @hidden @internal */\r\n  declare _$typeName: string; // actually put on prototype.\r\n  /** The serviceName for this DataService. __Read Only__ **/\r\n  declare serviceName: string;\r\n  /** The adapter name for the [[IDataServiceAdapter]] to be used with this service. __Read Only__  **/\r\n  declare adapterName: string;\r\n  /**  The [[IDataServiceAdapter]] implementation instance associated with this EntityManager. __Read Only__  **/\r\n  declare adapterInstance?: DataServiceAdapter;\r\n  /** The adapter name for the [[IUriBuilderAdapter]] to be used with this service. __Read Only__  **/\r\n  declare uriBuilderName: string;\r\n  /**  The [[IUriBuilderAdapter]] implementation instance associated with this EntityManager. __Read Only__  **/\r\n  declare uriBuilder?: UriBuilderAdapter;\r\n  /** Whether the server can provide metadata for this service. __Read Only__   **/\r\n  declare hasServerMetadata: boolean;\r\n  /** The [[JsonResultsAdapter]] used to process the results of any query against this DataService. __Read Only__ **/\r\n  declare jsonResultsAdapter: JsonResultsAdapter;\r\n  /** Whether to use JSONP when performing a 'GET' request against this service. __Read Only__  **/\r\n  declare useJsonp: boolean;\r\n\r\n  /**   DataService constructor\r\n  >     var dataService = new DataService({\r\n  >         serviceName: altServiceName,\r\n  >         hasServerMetadata: false\r\n  >     });\r\n\r\n  >     var metadataStore = new MetadataStore({\r\n  >         namingConvention: NamingConvention.camelCase\r\n  >     });\r\n\r\n  >     return new EntityManager({\r\n  >         dataService: dataService,\r\n  >         metadataStore: metadataStore\r\n  >     });\r\n  @param config - A configuration object.\r\n  **/\r\n  constructor(config?: DataServiceConfig) {\r\n    updateWithConfig(this, config);\r\n  }\r\n\r\n\r\n  /**\r\n  Returns a copy of this DataService with the specified properties applied.\r\n  @param config - The configuration object to apply to create a new DataService.\r\n  **/\r\n  using(config: DataServiceConfig) {\r\n    if (!config) return this;\r\n    let result = new DataService(this);\r\n    return updateWithConfig(result, config);\r\n  }\r\n\r\n  static resolve(dataServices: DataService[]) {\r\n    // final defaults\r\n    // Deliberate use of 'as any' below.\r\n    (dataServices as any).push({\r\n      hasServerMetadata: true,\r\n      useJsonp: false\r\n    });\r\n    let ds = new DataService(core.resolveProperties(dataServices,\r\n        [\"serviceName\", \"adapterName\", \"uriBuilderName\", \"hasServerMetadata\", \"jsonResultsAdapter\", \"useJsonp\"]));\r\n\r\n    if (!ds.serviceName) {\r\n      throw new Error(\"Unable to resolve a 'serviceName' for this dataService\");\r\n    }\r\n    ds.adapterInstance = ds.adapterInstance || config.getAdapterInstance<DataServiceAdapter>(\"dataService\", ds.adapterName);\r\n    ds.jsonResultsAdapter = ds.jsonResultsAdapter || ds.adapterInstance!.jsonResultsAdapter;\r\n    ds.uriBuilder = ds.uriBuilder || config.getAdapterInstance<UriBuilderAdapter>(\"uriBuilder\", ds.uriBuilderName);\r\n    return ds;\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  static _normalizeServiceName(serviceName: string) {\r\n    serviceName = serviceName.trim();\r\n    if (serviceName.substr(-1) !== \"/\") {\r\n      return serviceName + '/';\r\n    } else {\r\n      return serviceName;\r\n    }\r\n  }\r\n\r\n  /**  */\r\n  toJSON() {\r\n    // don't use default value here - because we want to be able to distinguish undefined props for inheritence purposes.\r\n    return core.toJson(this, {\r\n      serviceName: null,\r\n      adapterName: null,\r\n      uriBuilderName: null,\r\n      hasServerMetadata: null,\r\n      jsonResultsAdapter: function (v: any) {\r\n        return v && v.name;\r\n      },\r\n      useJsonp: null\r\n    });\r\n  }\r\n\r\n  static fromJSON(json: any) {\r\n    json.jsonResultsAdapter = config._fetchObject(JsonResultsAdapter, json.jsonResultsAdapter);\r\n    return new DataService(json);\r\n  }\r\n\r\n  /**\r\n   Returns a url for this dataService with the specified suffix. This method handles dataService names either\r\n   with or without trailing '/'s.  If the suffix starts with \"http\" then it will be returned as-is.\r\n   @method qualifyUrl\r\n   @param suffix {String} The resulting url.\r\n   @return {a Url string}\r\n   **/\r\n  qualifyUrl(suffix: string) {\r\n    if (suffix && suffix.startsWith(\"http\")) {\r\n      return suffix;\r\n    }\r\n    let url = this.serviceName;\r\n    // remove any trailing \"/\"\r\n    if (core.stringEndsWith(url, \"/\")) {\r\n      url = url.substr(0, url.length - 1);\r\n    }\r\n    // ensure that it ends with \"/\" + suffix\r\n    suffix = \"/\" + suffix;\r\n    if (!core.stringEndsWith(url, suffix)) {\r\n      url = url + suffix;\r\n    }\r\n    return url;\r\n  }\r\n\r\n}\r\nDataService.prototype._$typeName = \"DataService\";\r\n\r\nfunction updateWithConfig(obj: DataService, dsConfig?: DataServiceConfig) {\r\n  if (dsConfig) {\r\n    assertConfig(dsConfig)\r\n        .whereParam(\"serviceName\").isOptional()\r\n        .whereParam(\"adapterName\").isString().isOptional()\r\n        .whereParam(\"uriBuilderName\").isString().isOptional()\r\n        .whereParam(\"hasServerMetadata\").isBoolean().isOptional()\r\n        .whereParam(\"jsonResultsAdapter\").isInstanceOf(JsonResultsAdapter).isOptional()\r\n        .whereParam(\"useJsonp\").isBoolean().isOptional()\r\n        .applyAll(obj);\r\n    obj.serviceName = obj.serviceName && DataService._normalizeServiceName(obj.serviceName);\r\n    obj.adapterInstance = obj.adapterName ?  config.getAdapterInstance<DataServiceAdapter>(\"dataService\", obj.adapterName) : undefined;\r\n    obj.uriBuilder = obj.uriBuilderName ? config.getAdapterInstance<UriBuilderAdapter>(\"uriBuilder\", obj.uriBuilderName) : undefined;\r\n  }\r\n  return obj;\r\n}\r\n\r\nexport interface NodeMeta {\r\n  entityType?: EntityType;\r\n  nodeId?: string;\r\n  nodeRefId?: string;\r\n  ignore?: boolean;\r\n  passThru?: boolean;\r\n  extraMetadata?: any;\r\n}\r\n\r\nexport interface NodeContext {\r\n  nodeType: string;\r\n  propertyName?: string;\r\n  navigationProperty?: NavigationProperty;\r\n}\r\n\r\n/** Configuration info to be passed to the [[JsonResultsAdapter]] constructor */\r\nexport interface JsonResultsAdapterConfig {\r\n  /** The name of this adapter.  This name is used to uniquely identify and locate this instance when an 'exported' JsonResultsAdapter is later imported. */\r\n  name: string;\r\n  /** A Function that is called once per query operation to extract the 'payload' from any json received over the wire. \r\n  This method has a default implementation which to simply return the \"results\" property from any json returned as a result of executing the query. \r\n  */\r\n  extractResults?: Function;\r\n  /** A function that is called once per save operation to extract the entities from any json received over the wire.  Must return an array.\r\n  This method has a default implementation which simply returns the \"entities\" property from any json returned as a result of executing the save. */\r\n  extractSaveResults?: Function;\r\n  /** A function that is called once per save operation to extract the key mappings from any json received over the wire.  Must return an array.\r\n  This method has a default implementation which simply returns the \"keyMappings\" property from any json returned as a result of executing the save. */\r\n  extractKeyMappings?: (data: {}) => KeyMapping[];\r\n  /** A function that is called once per save operation to extract any deleted keys from any json received over the wire.  Must return an array.\r\n  This method has a default implementation which simply returns an empty array. */\r\n  extractDeletedKeys?: (data: {}) => any[]; // TODO: refine\r\n  /** A visitor method that will be called on each node of the returned payload. */\r\n  visitNode?: (v: any, mc?: MappingContext, nodeContext?: NodeContext) => NodeMeta;\r\n\r\n}\r\n\r\n/**\r\nA JsonResultsAdapter instance is used to provide custom extraction and parsing logic on the json results returned by any web service.\r\nThis facility makes it possible for breeze to talk to virtually any web service and return objects that will be first class 'breeze' citizens.\r\n**/\r\nexport class JsonResultsAdapter {\r\n  /** @hidden @internal */\r\n  _$typeName: string; // actually put on prototype.\r\n  /** The name of this adapter.  This name is used to uniquely identify and locate this instance when an 'exported' JsonResultsAdapter is later imported. */\r\n  name: string;\r\n  /** A Function that is called once per query operation to extract the 'payload' from any json received over the wire. \r\n  This method has a default implementation which simply returns the \"results\" property from any json returned as a result of executing the query. */\r\n  extractResults: Function; // TODO - refine\r\n  /** A function that is called once per save operation to extract the entities from any json received over the wire.  Must return an array.\r\n  This method has a default implementation which simply returns the \"entities\" property from any json returned as a result of executing the save. */\r\n  extractSaveResults: Function;\r\n    /** A function that is called once per save operation to extract the key mappings from any json received over the wire.  Must return an array.\r\n  This method has a default implementation which simply returns the \"keyMappings\" property from any json returned as a result of executing the save. */\r\n  extractKeyMappings:  (data: {}) => KeyMapping[];\r\n  /** A function that is called once per save operation to extract any deleted keys from any json received over the wire.  Must return an array.\r\n  This method has a default implementation which is to simply returns the \"deletedKeys\" property from any json returned as a result of executing the save. */\r\n  extractDeletedKeys?: (data: {}) => any[]; // TODO: refine\r\n  /** A visitor method that will be called on each node of the returned payload. */\r\n  visitNode: Function;\r\n\r\n  /**\r\n  JsonResultsAdapter constructor\r\n\r\n  @example\r\n      //\r\n      var jsonResultsAdapter = new JsonResultsAdapter({\r\n          name: \"test1e\",\r\n          extractResults: function(json) {\r\n              return json.results;\r\n          },\r\n          visitNode: function(node, mappingContext, nodeContext) {\r\n              var entityType = normalizeTypeName(node.$type);\r\n              var propertyName = nodeContext.propertyName;\r\n              var ignore = propertyName && propertyName.substr(0, 1) === \"$\";\r\n\r\n              return {\r\n                  entityType: entityType,\r\n                  nodeId: node.$id,\r\n                  nodeRefId: node.$ref,\r\n                  ignore: ignore,\r\n                  passThru: false // default\r\n              };\r\n          }\r\n      });\r\n\r\n      var dataService = new DataService( {\r\n              serviceName: \"breeze/foo\",\r\n              jsonResultsAdapter: jsonResultsAdapter\r\n      });\r\n\r\n      var entityManager = new EntityManager( {\r\n          dataService: dataService\r\n      });\r\n\r\n  @param config - A configuration object.\r\n\r\n  **/\r\n  constructor(jsConfig: JsonResultsAdapterConfig) {\r\n    if (arguments.length !== 1) {\r\n      throw new Error(\"The JsonResultsAdapter ctor should be called with a single argument that is a configuration object.\");\r\n    }\r\n\r\n    assertConfig(jsConfig)\r\n        .whereParam(\"name\").isNonEmptyString()\r\n        .whereParam(\"extractResults\").isFunction().isOptional().withDefault(extractResultsDefault)\r\n        .whereParam(\"extractSaveResults\").isFunction().isOptional().withDefault(extractSaveResultsDefault)\r\n        .whereParam(\"extractKeyMappings\").isFunction().isOptional().withDefault(extractKeyMappingsDefault)\r\n        .whereParam(\"extractDeletedKeys\").isFunction().isOptional().withDefault(extractDeletedKeysDefault)\r\n        .whereParam(\"visitNode\").isFunction()\r\n        .applyAll(this);\r\n    config._storeObject(this, \"JsonResultsAdapter\", this.name);\r\n  }\r\n\r\n}\r\nJsonResultsAdapter.prototype._$typeName = \"JsonResultsAdapter\";\r\n\r\nfunction extractResultsDefault(data: any) {\r\n  return data.results;\r\n}\r\n\r\nfunction extractSaveResultsDefault(data: any) {\r\n  return data.entities || data.Entities || [];\r\n}\r\n\r\nfunction extractKeyMappingsDefault(data: any) {\r\n  return data.keyMappings || data.KeyMappings || [];\r\n}\r\n\r\nfunction extractDeletedKeysDefault(data: any) {\r\n  return data.deletedKeys || data.DeletedKeys || [];\r\n}\r\n\r\n"]}