geoserver-node-client 1.6.1 → 1.6.2

package/dist/src/layer.js

@@ -1,14 +1,10 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports["default"] = void 0;
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+exports.default = void 0;
 var _nodeFetch = _interopRequireDefault(require("node-fetch"));
 var _geoserver = require("./util/geoserver.js");
 var _about = _interopRequireDefault(require("./about.js"));
@@ -17,15 +13,14 @@ var _about = _interopRequireDefault(require("./about.js"));
  *
  * @module LayerClient
  */
-var LayerClient = exports["default"] = /*#__PURE__*/function () {
+class LayerClient {
   /**
    * Creates a GeoServer REST LayerClient instance.
    *
    * @param {String} url The URL of the GeoServer REST API endpoint
    * @param {String} auth The Basic Authentication string
    */
-  function LayerClient(url, auth) {
-    (0, _classCallCheck2["default"])(this, LayerClient);
+  constructor(url, auth) {
     this.url = url;
     this.auth = auth;
   }
@@ -41,1301 +36,737 @@ var LayerClient = exports["default"] = /*#__PURE__*/function () {
    *
    * @returns {Object} An object with layer information or undefined if it cannot be found
    */
-  return (0, _createClass2["default"])(LayerClient, [{
-    key: "get",
-    value: (function () {
-      var _get = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(workspace, layerName) {
-        var qualifiedName, response, grc, geoServerResponse;
-        return _regenerator["default"].wrap(function (_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              if (workspace) {
-                qualifiedName = "".concat(workspace, ":").concat(layerName);
-              } else {
-                qualifiedName = layerName;
-              }
-              _context.next = 1;
-              return (0, _nodeFetch["default"])(this.url + 'layers/' + qualifiedName + '.json', {
-                credentials: 'include',
-                method: 'GET',
-                headers: {
-                  Authorization: this.auth
-                }
-              });
-            case 1:
-              response = _context.sent;
-              if (response.ok) {
-                _context.next = 5;
-                break;
-              }
-              grc = new _about["default"](this.url, this.auth);
-              _context.next = 2;
-              return grc.exists();
-            case 2:
-              if (!_context.sent) {
-                _context.next = 3;
-                break;
-              }
-              return _context.abrupt("return");
-            case 3:
-              _context.next = 4;
-              return (0, _geoserver.getGeoServerResponseText)(response);
-            case 4:
-              geoServerResponse = _context.sent;
-              throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
-            case 5:
-              return _context.abrupt("return", response.json());
-            case 6:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee, this);
-      }));
-      function get(_x, _x2) {
-        return _get.apply(this, arguments);
+  async get(workspace, layerName) {
+    let qualifiedName;
+    if (workspace) {
+      qualifiedName = `${workspace}:${layerName}`;
+    } else {
+      qualifiedName = layerName;
+    }
+    const response = await (0, _nodeFetch.default)(this.url + 'layers/' + qualifiedName + '.json', {
+      credentials: 'include',
+      method: 'GET',
+      headers: {
+        Authorization: this.auth
       }
-      return get;
-    }()
-    /**
-     * Sets the attribution text and link of a layer.
-     *
-     * @param {String} workspace The name of the workspace, can be undefined
-     * @param {String} layerName The name of the layer to query
-     * @param {String} [attributionText] The attribution text
-     * @param {String} [attributionLink] The attribution link
-     *
-     * @throws Error if request fails
-     */
-    )
-  }, {
-    key: "modifyAttribution",
-    value: (function () {
-      var _modifyAttribution = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2(workspace, layerName, attributionText, attributionLink) {
-        var qualifiedName, jsonBody, url, response, geoServerResponse;
-        return _regenerator["default"].wrap(function (_context2) {
-          while (1) switch (_context2.prev = _context2.next) {
-            case 0:
-              if (workspace) {
-                qualifiedName = "".concat(workspace, ":").concat(layerName);
-              } else {
-                qualifiedName = layerName;
-              }
-              // take existing layer properties as template
-              _context2.next = 1;
-              return this.get(workspace, layerName);
-            case 1:
-              jsonBody = _context2.sent;
-              if (!(!jsonBody || !jsonBody.layer || !jsonBody.layer.attribution)) {
-                _context2.next = 2;
-                break;
-              }
-              throw new _geoserver.GeoServerResponseError("layer '".concat(workspace, ":").concat(layerName, "' misses the property 'attribution'"));
-            case 2:
-              // set attribution text and link
-              if (attributionText) {
-                jsonBody.layer.attribution.title = attributionText;
-              }
-              if (attributionLink) {
-                jsonBody.layer.attribution.href = attributionLink;
-              }
-              url = this.url + 'layers/' + qualifiedName + '.json';
-              _context2.next = 3;
-              return (0, _nodeFetch["default"])(url, {
-                credentials: 'include',
-                method: 'PUT',
-                headers: {
-                  Authorization: this.auth,
-                  'Content-Type': 'application/json'
-                },
-                body: JSON.stringify(jsonBody)
-              });
-            case 3:
-              response = _context2.sent;
-              if (response.ok) {
-                _context2.next = 5;
-                break;
-              }
-              _context2.next = 4;
-              return (0, _geoserver.getGeoServerResponseText)(response);
-            case 4:
-              geoServerResponse = _context2.sent;
-              throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
-            case 5:
-            case "end":
-              return _context2.stop();
-          }
-        }, _callee2, this);
-      }));
-      function modifyAttribution(_x3, _x4, _x5, _x6) {
-        return _modifyAttribution.apply(this, arguments);
+    });
+    if (!response.ok) {
+      const grc = new _about.default(this.url, this.auth);
+      if (await grc.exists()) {
+        // GeoServer exists, but requested item does not exist,  we return empty
+        return;
+      } else {
+        // There was a general problem with GeoServer
+        const geoServerResponse = await (0, _geoserver.getGeoServerResponseText)(response);
+        throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
       }
-      return modifyAttribution;
-    }()
-    /**
-     * Returns all layers in the GeoServer.
-     *
-     * @throws Error if request fails
-     *
-     * @returns {Object} An object with all layer information
-     */
-    )
-  }, {
-    key: "getAll",
-    value: (function () {
-      var _getAll = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3() {
-        var response, geoServerResponse;
-        return _regenerator["default"].wrap(function (_context3) {
-          while (1) switch (_context3.prev = _context3.next) {
-            case 0:
-              _context3.next = 1;
-              return (0, _nodeFetch["default"])(this.url + 'layers.json', {
-                credentials: 'include',
-                method: 'GET',
-                headers: {
-                  Authorization: this.auth
-                }
-              });
-            case 1:
-              response = _context3.sent;
-              if (response.ok) {
-                _context3.next = 3;
-                break;
-              }
-              _context3.next = 2;
-              return (0, _geoserver.getGeoServerResponseText)(response);
-            case 2:
-              geoServerResponse = _context3.sent;
-              throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
-            case 3:
-              return _context3.abrupt("return", response.json());
-            case 4:
-            case "end":
-              return _context3.stop();
-          }
-        }, _callee3, this);
-      }));
-      function getAll() {
-        return _getAll.apply(this, arguments);
+    }
+    return response.json();
+  }
+
+  /**
+   * Sets the attribution text and link of a layer.
+   *
+   * @param {String} workspace The name of the workspace, can be undefined
+   * @param {String} layerName The name of the layer to query
+   * @param {String} [attributionText] The attribution text
+   * @param {String} [attributionLink] The attribution link
+   *
+   * @throws Error if request fails
+   */
+  async modifyAttribution(workspace, layerName, attributionText, attributionLink) {
+    let qualifiedName;
+    if (workspace) {
+      qualifiedName = `${workspace}:${layerName}`;
+    } else {
+      qualifiedName = layerName;
+    }
+    // take existing layer properties as template
+    const jsonBody = await this.get(workspace, layerName);
+    if (!jsonBody || !jsonBody.layer || !jsonBody.layer.attribution) {
+      throw new _geoserver.GeoServerResponseError(`layer '${workspace}:${layerName}' misses the property 'attribution'`);
+    }
+
+    // set attribution text and link
+    if (attributionText) {
+      jsonBody.layer.attribution.title = attributionText;
+    }
+    if (attributionLink) {
+      jsonBody.layer.attribution.href = attributionLink;
+    }
+    const url = this.url + 'layers/' + qualifiedName + '.json';
+    const response = await (0, _nodeFetch.default)(url, {
+      credentials: 'include',
+      method: 'PUT',
+      headers: {
+        Authorization: this.auth,
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(jsonBody)
+    });
+    if (!response.ok) {
+      const geoServerResponse = await (0, _geoserver.getGeoServerResponseText)(response);
+      throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
+    }
+  }
+
+  /**
+   * Returns all layers in the GeoServer.
+   *
+   * @throws Error if request fails
+   *
+   * @returns {Object} An object with all layer information
+   */
+  async getAll() {
+    const response = await (0, _nodeFetch.default)(this.url + 'layers.json', {
+      credentials: 'include',
+      method: 'GET',
+      headers: {
+        Authorization: this.auth
       }
-      return getAll;
-    }()
-    /**
-     * Get all layers of a workspace.
-     *
-     * @param {String} workspace The workspace
-     *
-     * @throws Error if request fails
-     *
-     * @return {Object} An object with the information about the layers
-     */
-    )
-  }, {
-    key: "getLayers",
-    value: (function () {
-      var _getLayers = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee4(workspace) {
-        var response, geoServerResponse;
-        return _regenerator["default"].wrap(function (_context4) {
-          while (1) switch (_context4.prev = _context4.next) {
-            case 0:
-              _context4.next = 1;
-              return (0, _nodeFetch["default"])(this.url + 'workspaces/' + workspace + '/layers.json', {
-                credentials: 'include',
-                method: 'GET',
-                headers: {
-                  Authorization: this.auth
-                }
-              });
-            case 1:
-              response = _context4.sent;
-              if (response.ok) {
-                _context4.next = 3;
-                break;
-              }
-              _context4.next = 2;
-              return (0, _geoserver.getGeoServerResponseText)(response);
-            case 2:
-              geoServerResponse = _context4.sent;
-              throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
-            case 3:
-              _context4.next = 4;
-              return response.json();
-            case 4:
-              return _context4.abrupt("return", _context4.sent);
-            case 5:
-            case "end":
-              return _context4.stop();
-          }
-        }, _callee4, this);
-      }));
-      function getLayers(_x7) {
-        return _getLayers.apply(this, arguments);
+    });
+    if (!response.ok) {
+      const geoServerResponse = await (0, _geoserver.getGeoServerResponseText)(response);
+      throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
+    }
+    return response.json();
+  }
+
+  /**
+   * Get all layers of a workspace.
+   *
+   * @param {String} workspace The workspace
+   *
+   * @throws Error if request fails
+   *
+   * @return {Object} An object with the information about the layers
+   */
+  async getLayers(workspace) {
+    const response = await (0, _nodeFetch.default)(this.url + 'workspaces/' + workspace + '/layers.json', {
+      credentials: 'include',
+      method: 'GET',
+      headers: {
+        Authorization: this.auth
       }
-      return getLayers;
-    }()
-    /**
-     * Returns information about a cascaded WMS layer.
-     *
-     * @param {String} workspace The workspace
-     * @param {String} datastore The datastore
-     * @param {String} layerName The WMS layer name
-     *
-     * @throws Error if request fails
-     *
-     * @returns {Object} An object with layer information or undefined if it cannot be found
-     */
-    )
-  }, {
-    key: "getWmsLayer",
-    value: (function () {
-      var _getWmsLayer = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee5(workspace, datastore, layerName) {
-        var response, grc, geoServerResponse;
-        return _regenerator["default"].wrap(function (_context5) {
-          while (1) switch (_context5.prev = _context5.next) {
-            case 0:
-              _context5.next = 1;
-              return (0, _nodeFetch["default"])(this.url + 'workspaces/' + workspace + '/wmsstores/' + datastore + '/wmslayers/' + layerName + '.json', {
-                credentials: 'include',
-                method: 'GET',
-                headers: {
-                  Authorization: this.auth
-                }
-              });
-            case 1:
-              response = _context5.sent;
-              if (response.ok) {
-                _context5.next = 5;
-                break;
-              }
-              grc = new _about["default"](this.url, this.auth);
-              _context5.next = 2;
-              return grc.exists();
-            case 2:
-              if (!_context5.sent) {
-                _context5.next = 3;
-                break;
-              }
-              return _context5.abrupt("return");
-            case 3:
-              _context5.next = 4;
-              return (0, _geoserver.getGeoServerResponseText)(response);
-            case 4:
-              geoServerResponse = _context5.sent;
-              throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
-            case 5:
-              _context5.next = 6;
-              return response.json();
-            case 6:
-              return _context5.abrupt("return", _context5.sent);
-            case 7:
-            case "end":
-              return _context5.stop();
-          }
-        }, _callee5, this);
-      }));
-      function getWmsLayer(_x8, _x9, _x0) {
-        return _getWmsLayer.apply(this, arguments);
+    });
+    if (!response.ok) {
+      const geoServerResponse = await (0, _geoserver.getGeoServerResponseText)(response);
+      throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
+    }
+    return await response.json();
+  }
+
+  /**
+   * Returns information about a cascaded WMS layer.
+   *
+   * @param {String} workspace The workspace
+   * @param {String} datastore The datastore
+   * @param {String} layerName The WMS layer name
+   *
+   * @throws Error if request fails
+   *
+   * @returns {Object} An object with layer information or undefined if it cannot be found
+   */
+  async getWmsLayer(workspace, datastore, layerName) {
+    const response = await (0, _nodeFetch.default)(this.url + 'workspaces/' + workspace + '/wmsstores/' + datastore + '/wmslayers/' + layerName + '.json', {
+      credentials: 'include',
+      method: 'GET',
+      headers: {
+        Authorization: this.auth
+      }
+    });
+    if (!response.ok) {
+      const grc = new _about.default(this.url, this.auth);
+      if (await grc.exists()) {
+        // GeoServer exists, but requested item does not exist,  we return empty
+        return;
+      } else {
+        // There was a general problem with GeoServer
+        const geoServerResponse = await (0, _geoserver.getGeoServerResponseText)(response);
+        throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
       }
-      return getWmsLayer;
-    }() // TODO: automated test needed
-    /**
-     * Returns information about a cascaded WMTS layer.
-     *
-     * @param {String} workspace The workspace
-     * @param {String} datastore The datastore
-     * @param {String} layerName The WMTS layer name
-     *
-     * @throws Error if request fails
-     *
-     * @returns {Object} An object with layer information or undefined if it cannot be found
-     */
-    )
-  }, {
-    key: "getWmtsLayer",
-    value: function () {
-      var _getWmtsLayer = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee6(workspace, datastore, layerName) {
-        var response, grc, geoServerResponse;
-        return _regenerator["default"].wrap(function (_context6) {
-          while (1) switch (_context6.prev = _context6.next) {
-            case 0:
-              _context6.next = 1;
-              return (0, _nodeFetch["default"])(this.url + 'workspaces/' + workspace + '/wmtsstores/' + datastore + '/layers/' + layerName + '.json', {
-                credentials: 'include',
-                method: 'GET',
-                headers: {
-                  Authorization: this.auth
-                }
-              });
-            case 1:
-              response = _context6.sent;
-              if (response.ok) {
-                _context6.next = 5;
-                break;
-              }
-              grc = new _about["default"](this.url, this.auth);
-              _context6.next = 2;
-              return grc.exists();
-            case 2:
-              if (!_context6.sent) {
-                _context6.next = 3;
-                break;
-              }
-              return _context6.abrupt("return");
-            case 3:
-              _context6.next = 4;
-              return (0, _geoserver.getGeoServerResponseText)(response);
-            case 4:
-              geoServerResponse = _context6.sent;
-              throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
-            case 5:
-              _context6.next = 6;
-              return response.json();
-            case 6:
-              return _context6.abrupt("return", _context6.sent);
-            case 7:
-            case "end":
-              return _context6.stop();
-          }
-        }, _callee6, this);
-      }));
-      function getWmtsLayer(_x1, _x10, _x11) {
-        return _getWmtsLayer.apply(this, arguments);
+    }
+    return await response.json();
+  }
+
+  // TODO: automated test needed
+  /**
+   * Returns information about a cascaded WMTS layer.
+   *
+   * @param {String} workspace The workspace
+   * @param {String} datastore The datastore
+   * @param {String} layerName The WMTS layer name
+   *
+   * @throws Error if request fails
+   *
+   * @returns {Object} An object with layer information or undefined if it cannot be found
+   */
+  async getWmtsLayer(workspace, datastore, layerName) {
+    const response = await (0, _nodeFetch.default)(this.url + 'workspaces/' + workspace + '/wmtsstores/' + datastore + '/layers/' + layerName + '.json', {
+      credentials: 'include',
+      method: 'GET',
+      headers: {
+        Authorization: this.auth
+      }
+    });
+    if (!response.ok) {
+      const grc = new _about.default(this.url, this.auth);
+      if (await grc.exists()) {
+        // GeoServer exists, but requested item does not exist,  we return empty
+        return;
+      } else {
+        // There was a general problem with GeoServer
+        const geoServerResponse = await (0, _geoserver.getGeoServerResponseText)(response);
+        throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
+      }
+    }
+    return await response.json();
+  }
+
+  /**
+   * Publishes a FeatureType in the default data store of the workspace.
+   *
+   * @param {String} workspace Workspace to publish FeatureType in
+   * @param {String} [nativeName] Native name of FeatureType
+   * @param {String} name Published name of FeatureType
+   * @param {String} [title] Published title of FeatureType
+   * @param {String} [srs="EPSG:4326"] The SRS of the FeatureType
+   * @param {String} enabled Flag to enable FeatureType by default
+   * @param {String} [abstract] The abstract of the layer
+   *
+   * @throws Error if request fails
+   */
+  async publishFeatureTypeDefaultDataStore(workspace, nativeName, name, title, srs, enabled, abstract) {
+    const body = {
+      featureType: {
+        name: name,
+        nativeName: nativeName || name,
+        title: title || name,
+        srs: srs || 'EPSG:4326',
+        enabled: enabled,
+        abstract: abstract || ''
+      }
+    };
+    const response = await (0, _nodeFetch.default)(this.url + 'workspaces/' + workspace + '/featuretypes', {
+      credentials: 'include',
+      method: 'POST',
+      headers: {
+        Authorization: this.auth,
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const geoServerResponse = await (0, _geoserver.getGeoServerResponseText)(response);
+      throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
+    }
+  }
+
+  /**
+   * Publishes a FeatureType in the given data store of the workspace.
+   *
+   * @param {String} workspace Workspace to publish FeatureType in
+   * @param {String} dataStore The datastore where the FeatureType's data is in
+   * @param {String} [nativeName] Native name of FeatureType
+   * @param {String} name Published name of FeatureType
+   * @param {String} [title] Published title of FeatureType
+   * @param {String} [srs="EPSG:4326"] The SRS of the FeatureType
+   * @param {String} enabled Flag to enable FeatureType by default
+   * @param {String} [abstract] The abstract of the layer
+   * @param {String} [nativeBoundingBox] The native BoundingBox of the FeatureType (has to be set if no data is in store at creation time)
+   *
+   * @throws Error if request fails
+   */
+  async publishFeatureType(workspace, dataStore, nativeName, name, title, srs, enabled, abstract, nativeBoundingBox) {
+    // apply CRS info for native BBOX if not provided
+    if (nativeBoundingBox && !nativeBoundingBox.crs) {
+      nativeBoundingBox.crs = {
+        '@class': 'projected',
+        $: srs
+      };
+    }
+    const body = {
+      featureType: {
+        name: name || nativeName,
+        nativeName: nativeName,
+        title: title || name,
+        srs: srs || 'EPSG:4326',
+        enabled: enabled,
+        abstract: abstract || '',
+        nativeBoundingBox: nativeBoundingBox
+      }
+    };
+    const response = await (0, _nodeFetch.default)(this.url + 'workspaces/' + workspace + '/datastores/' + dataStore + '/featuretypes', {
+      credentials: 'include',
+      method: 'POST',
+      headers: {
+        Authorization: this.auth,
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const geoServerResponse = await (0, _geoserver.getGeoServerResponseText)(response);
+      throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
+    }
+  }
+
+  /**
+   * Get detailed information about a FeatureType.
+   *
+   * @param {String} workspace The workspace of the FeatureType
+   * @param {String} datastore The datastore of the FeatureType
+   * @param {String} name The name of the FeatureType
+   *
+   * @throws Error if request fails
+   *
+   * @returns {Object} The object of the FeatureType
+   */
+  async getFeatureType(workspace, datastore, name) {
+    const url = this.url + 'workspaces/' + workspace + '/datastores/' + datastore + '/featuretypes/' + name + '.json';
+    const response = await (0, _nodeFetch.default)(url, {
+      credentials: 'include',
+      method: 'GET',
+      headers: {
+        Authorization: this.auth
+      }
+    });
+    if (!response.ok) {
+      const grc = new _about.default(this.url, this.auth);
+      if (await grc.exists()) {
+        // GeoServer exists, but requested item does not exist, we return empty
+        return;
+      } else {
+        // There was a general problem with GeoServer
+        const geoServerResponse = await (0, _geoserver.getGeoServerResponseText)(response);
+        throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
+      }
+    }
+    return response.json();
+  }
+
+  /**
+   * Get detailed information about a FeatureType.
+   *
+   * @param {String} workspace The workspace of the FeatureType
+   * @param {String} name The name of the FeatureType
+   *
+   * @throws GeoServerResponseError if request fails or layer does not exist or lacks the right properties.
+   *
+   * @returns {Object} The object of the FeatureType
+   */
+  async getFeatureTypeFromLayer(workspace, layer) {
+    const layerObj = await this.get(workspace, layer);
+    if (!layerObj || !layerObj.layer || !layerObj.layer.resource || !layerObj.layer.resource.href) {
+      throw new _geoserver.GeoServerResponseError(`Layer '${workspace}:${layer}' does not exist or lacks the layer.resource.href property.`);
+    }
+    const url = layerObj?.layer?.resource?.href;
+    const response = await (0, _nodeFetch.default)(url, {
+      credentials: 'include',
+      method: 'GET',
+      headers: {
+        Authorization: this.auth
       }
-      return getWmtsLayer;
-    }()
-    /**
-     * Publishes a FeatureType in the default data store of the workspace.
-     *
-     * @param {String} workspace Workspace to publish FeatureType in
-     * @param {String} [nativeName] Native name of FeatureType
-     * @param {String} name Published name of FeatureType
-     * @param {String} [title] Published title of FeatureType
-     * @param {String} [srs="EPSG:4326"] The SRS of the FeatureType
-     * @param {String} enabled Flag to enable FeatureType by default
-     * @param {String} [abstract] The abstract of the layer
-     *
-     * @throws Error if request fails
-     */
-  }, {
-    key: "publishFeatureTypeDefaultDataStore",
-    value: (function () {
-      var _publishFeatureTypeDefaultDataStore = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee7(workspace, nativeName, name, title, srs, enabled, _abstract) {
-        var body, response, geoServerResponse;
-        return _regenerator["default"].wrap(function (_context7) {
-          while (1) switch (_context7.prev = _context7.next) {
-            case 0:
-              body = {
-                featureType: {
-                  name: name,
-                  nativeName: nativeName || name,
-                  title: title || name,
-                  srs: srs || 'EPSG:4326',
-                  enabled: enabled,
-                  "abstract": _abstract || ''
-                }
-              };
-              _context7.next = 1;
-              return (0, _nodeFetch["default"])(this.url + 'workspaces/' + workspace + '/featuretypes', {
-                credentials: 'include',
-                method: 'POST',
-                headers: {
-                  Authorization: this.auth,
-                  'Content-Type': 'application/json'
-                },
-                body: JSON.stringify(body)
-              });
-            case 1:
-              response = _context7.sent;
-              if (response.ok) {
-                _context7.next = 3;
-                break;
-              }
-              _context7.next = 2;
-              return (0, _geoserver.getGeoServerResponseText)(response);
-            case 2:
-              geoServerResponse = _context7.sent;
-              throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
-            case 3:
-            case "end":
-              return _context7.stop();
-          }
-        }, _callee7, this);
-      }));
-      function publishFeatureTypeDefaultDataStore(_x12, _x13, _x14, _x15, _x16, _x17, _x18) {
-        return _publishFeatureTypeDefaultDataStore.apply(this, arguments);
+    });
+    if (!response.ok) {
+      const geoServerResponse = await (0, _geoserver.getGeoServerResponseText)(response);
+      throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
+    }
+    return response.json();
+  }
+
+  /**
+   *  Publishes a WMS layer.
+   *
+   * @param {String} workspace Workspace to publish WMS layer in
+   * @param {String} dataStore The datastore where the WMS is connected
+   * @param {String} nativeName Native name of WMS layer
+   * @param {String} [name] Published name of WMS layer
+   * @param {String} [title] Published title of WMS layer
+   * @param {String} [srs="EPSG:4326"] The SRS of the WMS layer
+   * @param {String} enabled Flag to enable WMS layer by default
+   * @param {String} [abstract] The abstract of the layer
+   *
+   * @throws Error if request fails
+   */
+  async publishWmsLayer(workspace, dataStore, nativeName, name, title, srs, enabled, abstract) {
+    const body = {
+      wmsLayer: {
+        name: name || nativeName,
+        nativeName: nativeName,
+        title: title || name || nativeName,
+        srs: srs || 'EPSG:4326',
+        enabled: enabled,
+        abstract: abstract || ''
       }
-      return publishFeatureTypeDefaultDataStore;
-    }()
-    /**
-     * Publishes a FeatureType in the given data store of the workspace.
-     *
-     * @param {String} workspace Workspace to publish FeatureType in
-     * @param {String} dataStore The datastore where the FeatureType's data is in
-     * @param {String} [nativeName] Native name of FeatureType
-     * @param {String} name Published name of FeatureType
-     * @param {String} [title] Published title of FeatureType
-     * @param {String} [srs="EPSG:4326"] The SRS of the FeatureType
-     * @param {String} enabled Flag to enable FeatureType by default
-     * @param {String} [abstract] The abstract of the layer
-     * @param {String} [nativeBoundingBox] The native BoundingBox of the FeatureType (has to be set if no data is in store at creation time)
-     *
-     * @throws Error if request fails
-     */
-    )
-  }, {
-    key: "publishFeatureType",
-    value: (function () {
-      var _publishFeatureType = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee8(workspace, dataStore, nativeName, name, title, srs, enabled, _abstract2, nativeBoundingBox) {
-        var body, response, geoServerResponse;
-        return _regenerator["default"].wrap(function (_context8) {
-          while (1) switch (_context8.prev = _context8.next) {
-            case 0:
-              // apply CRS info for native BBOX if not provided
-              if (nativeBoundingBox && !nativeBoundingBox.crs) {
-                nativeBoundingBox.crs = {
-                  '@class': 'projected',
-                  $: srs
-                };
-              }
-              body = {
-                featureType: {
-                  name: name || nativeName,
-                  nativeName: nativeName,
-                  title: title || name,
-                  srs: srs || 'EPSG:4326',
-                  enabled: enabled,
-                  "abstract": _abstract2 || '',
-                  nativeBoundingBox: nativeBoundingBox
-                }
-              };
-              _context8.next = 1;
-              return (0, _nodeFetch["default"])(this.url + 'workspaces/' + workspace + '/datastores/' + dataStore + '/featuretypes', {
-                credentials: 'include',
-                method: 'POST',
-                headers: {
-                  Authorization: this.auth,
-                  'Content-Type': 'application/json'
-                },
-                body: JSON.stringify(body)
-              });
-            case 1:
-              response = _context8.sent;
-              if (response.ok) {
-                _context8.next = 3;
-                break;
-              }
-              _context8.next = 2;
-              return (0, _geoserver.getGeoServerResponseText)(response);
-            case 2:
-              geoServerResponse = _context8.sent;
-              throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
-            case 3:
-            case "end":
-              return _context8.stop();
-          }
-        }, _callee8, this);
-      }));
-      function publishFeatureType(_x19, _x20, _x21, _x22, _x23, _x24, _x25, _x26, _x27) {
-        return _publishFeatureType.apply(this, arguments);
+    };
+    const response = await (0, _nodeFetch.default)(this.url + 'workspaces/' + workspace + '/wmsstores/' + dataStore + '/wmslayers', {
+      credentials: 'include',
+      method: 'POST',
+      headers: {
+        Authorization: this.auth,
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const geoServerResponse = await (0, _geoserver.getGeoServerResponseText)(response);
+      throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
+    }
+  }
+
+  /**
+   * Publishes a raster stored in a database.
+   *
+   * @param {String} workspace Workspace to publish layer in
+   * @param {String} coverageStore The coveragestore where the layer's data is in
+   * @param {String} nativeName Native name of raster
+   * @param {String} name Published name of layer
+   * @param {String} [title] Published title of layer
+   * @param {String} [srs="EPSG:4326"] The SRS of the layer
+   * @param {String} enabled Flag to enable layer by default
+   * @param {String} [abstract] The abstract of the layer
+   *
+   * @throws Error if request fails
+   */
+  async publishDbRaster(workspace, coverageStore, nativeName, name, title, srs, enabled, abstract) {
+    const body = {
+      coverage: {
+        name: name || nativeName,
+        nativeName: nativeName,
+        title: title || name,
+        srs: srs,
+        enabled: enabled,
+        abstract: abstract || ''
       }
-      return publishFeatureType;
-    }()
-    /**
-     * Get detailed information about a FeatureType.
-     *
-     * @param {String} workspace The workspace of the FeatureType
-     * @param {String} datastore The datastore of the FeatureType
-     * @param {String} name The name of the FeatureType
-     *
-     * @throws Error if request fails
-     *
-     * @returns {Object} The object of the FeatureType
-     */
-    )
-  }, {
-    key: "getFeatureType",
-    value: (function () {
-      var _getFeatureType = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee9(workspace, datastore, name) {
-        var url, response, grc, geoServerResponse;
-        return _regenerator["default"].wrap(function (_context9) {
-          while (1) switch (_context9.prev = _context9.next) {
-            case 0:
-              url = this.url + 'workspaces/' + workspace + '/datastores/' + datastore + '/featuretypes/' + name + '.json';
-              _context9.next = 1;
-              return (0, _nodeFetch["default"])(url, {
-                credentials: 'include',
-                method: 'GET',
-                headers: {
-                  Authorization: this.auth
-                }
-              });
-            case 1:
-              response = _context9.sent;
-              if (response.ok) {
-                _context9.next = 5;
-                break;
-              }
-              grc = new _about["default"](this.url, this.auth);
-              _context9.next = 2;
-              return grc.exists();
-            case 2:
-              if (!_context9.sent) {
-                _context9.next = 3;
-                break;
-              }
-              return _context9.abrupt("return");
-            case 3:
-              _context9.next = 4;
-              return (0, _geoserver.getGeoServerResponseText)(response);
-            case 4:
-              geoServerResponse = _context9.sent;
-              throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
-            case 5:
-              return _context9.abrupt("return", response.json());
-            case 6:
-            case "end":
-              return _context9.stop();
-          }
-        }, _callee9, this);
-      }));
-      function getFeatureType(_x28, _x29, _x30) {
-        return _getFeatureType.apply(this, arguments);
+    };
+    const response = await (0, _nodeFetch.default)(this.url + 'workspaces/' + workspace + '/coveragestores/' + coverageStore + '/coverages', {
+      credentials: 'include',
+      method: 'POST',
+      headers: {
+        Authorization: this.auth,
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const geoServerResponse = await (0, _geoserver.getGeoServerResponseText)(response);
+      throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
+    }
+  }
+
+  /**
+   * Deletes a FeatureType.
+   *
+   * @param {String} workspace Workspace where layer to delete is in
+   * @param {String} datastore The datastore where the layer to delete is in
+   * @param {String} name Layer to delete
+   * @param {Boolean} recurse Flag to enable recursive deletion
+   *
+   * @throws Error if request fails
+   */
+  async deleteFeatureType(workspace, datastore, name, recurse) {
+    const response = await (0, _nodeFetch.default)(this.url + 'workspaces/' + workspace + '/datastores/' + datastore + '/featuretypes/' + name + '?recurse=' + recurse, {
+      credentials: 'include',
+      method: 'DELETE',
+      headers: {
+        Authorization: this.auth
       }
-      return getFeatureType;
-    }()
-    /**
-     * Get detailed information about a FeatureType.
-     *
-     * @param {String} workspace The workspace of the FeatureType
-     * @param {String} name The name of the FeatureType
-     *
-     * @throws GeoServerResponseError if request fails or layer does not exist or lacks the right properties.
-     *
-     * @returns {Object} The object of the FeatureType
-     */
-    )
-  }, {
-    key: "getFeatureTypeFromLayer",
-    value: (function () {
-      var _getFeatureTypeFromLayer = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee0(workspace, layer) {
-        var _layerObj$layer;
-        var layerObj, url, response, geoServerResponse;
-        return _regenerator["default"].wrap(function (_context0) {
-          while (1) switch (_context0.prev = _context0.next) {
-            case 0:
-              _context0.next = 1;
-              return this.get(workspace, layer);
-            case 1:
-              layerObj = _context0.sent;
-              if (!(!layerObj || !layerObj.layer || !layerObj.layer.resource || !layerObj.layer.resource.href)) {
-                _context0.next = 2;
-                break;
-              }
-              throw new _geoserver.GeoServerResponseError("Layer '".concat(workspace, ":").concat(layer, "' does not exist or lacks the layer.resource.href property."));
-            case 2:
-              url = layerObj === null || layerObj === void 0 || (_layerObj$layer = layerObj.layer) === null || _layerObj$layer === void 0 || (_layerObj$layer = _layerObj$layer.resource) === null || _layerObj$layer === void 0 ? void 0 : _layerObj$layer.href;
-              _context0.next = 3;
-              return (0, _nodeFetch["default"])(url, {
-                credentials: 'include',
-                method: 'GET',
-                headers: {
-                  Authorization: this.auth
-                }
-              });
-            case 3:
-              response = _context0.sent;
-              if (response.ok) {
-                _context0.next = 5;
-                break;
-              }
-              _context0.next = 4;
-              return (0, _geoserver.getGeoServerResponseText)(response);
-            case 4:
-              geoServerResponse = _context0.sent;
-              throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
-            case 5:
-              return _context0.abrupt("return", response.json());
-            case 6:
-            case "end":
-              return _context0.stop();
-          }
-        }, _callee0, this);
-      }));
-      function getFeatureTypeFromLayer(_x31, _x32) {
-        return _getFeatureTypeFromLayer.apply(this, arguments);
+    });
+    if (!response.ok) {
+      const geoServerResponse = await (0, _geoserver.getGeoServerResponseText)(response);
+      throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
+    }
+  }
+
+  /**
+   * Enables TIME dimension for the given coverage layer.
+   *
+   * @param {String} workspace Workspace where layer to enable time dimension for is in
+   * @param {String} datastore The datastore where the layer to enable time dimension for is in
+   * @param {String} name Layer to enable time dimension for
+   * @param {String} presentation Presentation type: 'LIST' or 'DISCRETE_INTERVAL' or 'CONTINUOUS_INTERVAL'
+   * @param {Number} resolution Resolution in milliseconds, e.g. 3600000 for 1 hour
+   * @param {String} defaultValue The default time value, e.g. 'MINIMUM' or 'MAXIMUM' or 'NEAREST' or 'FIXED'
+   * @param {Boolean} [nearestMatchEnabled] Enable nearest match
+   * @param {Boolean} [rawNearestMatchEnabled] Enable raw nearest match
+   * @param {String} [acceptableInterval] Acceptable interval for nearest match, e.g.'PT30M'
+   *
+   * @throws Error if request fails
+   */
+  async enableTimeCoverage(workspace, dataStore, name, presentation, resolution, defaultValue, nearestMatchEnabled, rawNearestMatchEnabled, acceptableInterval) {
+    const body = {
+      coverage: {
+        metadata: {
+          entry: [{
+            '@key': 'time',
+            dimensionInfo: {
+              enabled: true,
+              presentation: presentation || 'DISCRETE_INTERVAL',
+              resolution: resolution,
+              units: 'ISO8601',
+              defaultValue: {
+                strategy: defaultValue
+              },
+              nearestMatchEnabled: nearestMatchEnabled,
+              rawNearestMatchEnabled: rawNearestMatchEnabled,
+              acceptableInterval: acceptableInterval
+            }
+          }]
+        }
       }
-      return getFeatureTypeFromLayer;
-    }()
-    /**
-     *  Publishes a WMS layer.
-     *
-     * @param {String} workspace Workspace to publish WMS layer in
-     * @param {String} dataStore The datastore where the WMS is connected
-     * @param {String} nativeName Native name of WMS layer
-     * @param {String} [name] Published name of WMS layer
-     * @param {String} [title] Published title of WMS layer
-     * @param {String} [srs="EPSG:4326"] The SRS of the WMS layer
-     * @param {String} enabled Flag to enable WMS layer by default
-     * @param {String} [abstract] The abstract of the layer
-     *
-     * @throws Error if request fails
-     */
-    )
-  }, {
-    key: "publishWmsLayer",
-    value: (function () {
-      var _publishWmsLayer = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee1(workspace, dataStore, nativeName, name, title, srs, enabled, _abstract3) {
-        var body, response, geoServerResponse;
-        return _regenerator["default"].wrap(function (_context1) {
-          while (1) switch (_context1.prev = _context1.next) {
-            case 0:
-              body = {
-                wmsLayer: {
-                  name: name || nativeName,
-                  nativeName: nativeName,
-                  title: title || name || nativeName,
-                  srs: srs || 'EPSG:4326',
-                  enabled: enabled,
-                  "abstract": _abstract3 || ''
-                }
-              };
-              _context1.next = 1;
-              return (0, _nodeFetch["default"])(this.url + 'workspaces/' + workspace + '/wmsstores/' + dataStore + '/wmslayers', {
-                credentials: 'include',
-                method: 'POST',
-                headers: {
-                  Authorization: this.auth,
-                  'Content-Type': 'application/json'
-                },
-                body: JSON.stringify(body)
-              });
-            case 1:
-              response = _context1.sent;
-              if (response.ok) {
-                _context1.next = 3;
-                break;
-              }
-              _context1.next = 2;
-              return (0, _geoserver.getGeoServerResponseText)(response);
-            case 2:
-              geoServerResponse = _context1.sent;
-              throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
-            case 3:
-            case "end":
-              return _context1.stop();
-          }
-        }, _callee1, this);
-      }));
-      function publishWmsLayer(_x33, _x34, _x35, _x36, _x37, _x38, _x39, _x40) {
-        return _publishWmsLayer.apply(this, arguments);
+    };
+    const url = this.url + 'workspaces/' + workspace + '/coveragestores/' + dataStore + '/coverages/' + name + '.json';
+    const response = await (0, _nodeFetch.default)(url, {
+      credentials: 'include',
+      method: 'PUT',
+      headers: {
+        Authorization: this.auth,
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const geoServerResponse = await (0, _geoserver.getGeoServerResponseText)(response);
+      throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
+    }
+  }
+
+  /**
+   * Enables TIME dimension for the given FeatureType layer.
+   *
+   * @param {String} workspace Workspace containing layer to enable time dimension for
+   * @param {String} datastore The datastore containing the FeatureType to enable time dimension for
+   * @param {String} name FeatureType to enable time dimension for
+   * @param {String} attribute Data column / attribute holding the time values
+   * @param {String} presentation Presentation type: 'LIST' or 'DISCRETE_INTERVAL' or 'CONTINUOUS_INTERVAL'
+   * @param {Number} resolution Resolution in milliseconds, e.g. 3600000 for 1 hour
+   * @param {String} defaultValue The default time value, e.g. 'MINIMUM' or 'MAXIMUM' or 'NEAREST' or 'FIXED'
+   * @param {Boolean} [nearestMatchEnabled] Enable nearest match
+   * @param {Boolean} [rawNearestMatchEnabled] Enable raw nearest match
+   *
+   * @throws Error if request fails
+   */
+  async enableTimeFeatureType(workspace, dataStore, name, attribute, presentation, resolution, defaultValue, nearestMatchEnabled, rawNearestMatchEnabled, acceptableInterval) {
+    const body = {
+      featureType: {
+        metadata: {
+          entry: [{
+            '@key': 'time',
+            dimensionInfo: {
+              attribute: attribute,
+              presentation: presentation,
+              resolution: resolution,
+              units: 'ISO8601',
+              defaultValue: {
+                strategy: defaultValue
+              },
+              nearestMatchEnabled: nearestMatchEnabled,
+              rawNearestMatchEnabled: rawNearestMatchEnabled,
+              acceptableInterval: acceptableInterval
+            }
+          }]
+        }
       }
-      return publishWmsLayer;
-    }()
-    /**
-     * Publishes a raster stored in a database.
-     *
-     * @param {String} workspace Workspace to publish layer in
-     * @param {String} coverageStore The coveragestore where the layer's data is in
-     * @param {String} nativeName Native name of raster
-     * @param {String} name Published name of layer
-     * @param {String} [title] Published title of layer
-     * @param {String} [srs="EPSG:4326"] The SRS of the layer
-     * @param {String} enabled Flag to enable layer by default
-     * @param {String} [abstract] The abstract of the layer
-     *
-     * @throws Error if request fails
-     */
-    )
-  }, {
-    key: "publishDbRaster",
-    value: (function () {
-      var _publishDbRaster = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee10(workspace, coverageStore, nativeName, name, title, srs, enabled, _abstract4) {
-        var body, response, geoServerResponse;
-        return _regenerator["default"].wrap(function (_context10) {
-          while (1) switch (_context10.prev = _context10.next) {
-            case 0:
-              body = {
-                coverage: {
-                  name: name || nativeName,
-                  nativeName: nativeName,
-                  title: title || name,
-                  srs: srs,
-                  enabled: enabled,
-                  "abstract": _abstract4 || ''
-                }
-              };
-              _context10.next = 1;
-              return (0, _nodeFetch["default"])(this.url + 'workspaces/' + workspace + '/coveragestores/' + coverageStore + '/coverages', {
-                credentials: 'include',
-                method: 'POST',
-                headers: {
-                  Authorization: this.auth,
-                  'Content-Type': 'application/json'
-                },
-                body: JSON.stringify(body)
-              });
-            case 1:
-              response = _context10.sent;
-              if (response.ok) {
-                _context10.next = 3;
-                break;
-              }
-              _context10.next = 2;
-              return (0, _geoserver.getGeoServerResponseText)(response);
-            case 2:
-              geoServerResponse = _context10.sent;
-              throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
-            case 3:
-            case "end":
-              return _context10.stop();
-          }
-        }, _callee10, this);
-      }));
-      function publishDbRaster(_x41, _x42, _x43, _x44, _x45, _x46, _x47, _x48) {
-        return _publishDbRaster.apply(this, arguments);
+    };
+    const url = this.url + 'workspaces/' + workspace + '/datastores/' + dataStore + '/featuretypes/' + name + '.json';
+    const response = await (0, _nodeFetch.default)(url, {
+      credentials: 'include',
+      method: 'PUT',
+      headers: {
+        Authorization: this.auth,
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const geoServerResponse = await (0, _geoserver.getGeoServerResponseText)(response);
+      throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
+    }
+  }
+
+  /**
+   * Returns a dedicated coverage object.
+   *
+   * @param {String} workspace Workspace containing the coverage
+   * @param {String} coverageStore The coveragestore containing the coverage
+   * @param {String} name Coverage to query
+   *
+   * @throws Error if request fails
+   *
+   * @returns {Object} An object with coverage information or undefined if it cannot be found
+   */
+  async getCoverage(workspace, coverageStore, name) {
+    const url = this.url + 'workspaces/' + workspace + '/coveragestores/' + coverageStore + '/coverages/' + name + '.json';
+    const response = await (0, _nodeFetch.default)(url, {
+      credentials: 'include',
+      method: 'GET',
+      headers: {
+        Authorization: this.auth
       }
-      return publishDbRaster;
-    }()
-    /**
-     * Deletes a FeatureType.
-     *
-     * @param {String} workspace Workspace where layer to delete is in
-     * @param {String} datastore The datastore where the layer to delete is in
-     * @param {String} name Layer to delete
-     * @param {Boolean} recurse Flag to enable recursive deletion
-     *
-     * @throws Error if request fails
-     */
-    )
-  }, {
-    key: "deleteFeatureType",
-    value: (function () {
-      var _deleteFeatureType = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee11(workspace, datastore, name, recurse) {
-        var response, geoServerResponse;
-        return _regenerator["default"].wrap(function (_context11) {
-          while (1) switch (_context11.prev = _context11.next) {
-            case 0:
-              _context11.next = 1;
-              return (0, _nodeFetch["default"])(this.url + 'workspaces/' + workspace + '/datastores/' + datastore + '/featuretypes/' + name + '?recurse=' + recurse, {
-                credentials: 'include',
-                method: 'DELETE',
-                headers: {
-                  Authorization: this.auth
-                }
-              });
-            case 1:
-              response = _context11.sent;
-              if (response.ok) {
-                _context11.next = 3;
-                break;
-              }
-              _context11.next = 2;
-              return (0, _geoserver.getGeoServerResponseText)(response);
-            case 2:
-              geoServerResponse = _context11.sent;
-              throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
-            case 3:
-            case "end":
-              return _context11.stop();
-          }
-        }, _callee11, this);
-      }));
-      function deleteFeatureType(_x49, _x50, _x51, _x52) {
-        return _deleteFeatureType.apply(this, arguments);
+    });
+    if (!response.ok) {
+      const grc = new _about.default(this.url, this.auth);
+      if (await grc.exists()) {
+        // GeoServer exists, but requested item does not exist,  we return empty
+        return;
+      } else {
+        // There was a general problem with GeoServer
+        const geoServerResponse = await (0, _geoserver.getGeoServerResponseText)(response);
+        throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
       }
-      return deleteFeatureType;
-    }()
-    /**
-     * Enables TIME dimension for the given coverage layer.
-     *
-     * @param {String} workspace Workspace where layer to enable time dimension for is in
-     * @param {String} datastore The datastore where the layer to enable time dimension for is in
-     * @param {String} name Layer to enable time dimension for
-     * @param {String} presentation Presentation type: 'LIST' or 'DISCRETE_INTERVAL' or 'CONTINUOUS_INTERVAL'
-     * @param {Number} resolution Resolution in milliseconds, e.g. 3600000 for 1 hour
-     * @param {String} defaultValue The default time value, e.g. 'MINIMUM' or 'MAXIMUM' or 'NEAREST' or 'FIXED'
-     * @param {Boolean} [nearestMatchEnabled] Enable nearest match
-     * @param {Boolean} [rawNearestMatchEnabled] Enable raw nearest match
-     * @param {String} [acceptableInterval] Acceptable interval for nearest match, e.g.'PT30M'
-     *
-     * @throws Error if request fails
-     */
-    )
-  }, {
-    key: "enableTimeCoverage",
-    value: (function () {
-      var _enableTimeCoverage = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee12(workspace, dataStore, name, presentation, resolution, defaultValue, nearestMatchEnabled, rawNearestMatchEnabled, acceptableInterval) {
-        var body, url, response, geoServerResponse;
-        return _regenerator["default"].wrap(function (_context12) {
-          while (1) switch (_context12.prev = _context12.next) {
-            case 0:
-              body = {
-                coverage: {
-                  metadata: {
-                    entry: [{
-                      '@key': 'time',
-                      dimensionInfo: {
-                        enabled: true,
-                        presentation: presentation || 'DISCRETE_INTERVAL',
-                        resolution: resolution,
-                        units: 'ISO8601',
-                        defaultValue: {
-                          strategy: defaultValue
-                        },
-                        nearestMatchEnabled: nearestMatchEnabled,
-                        rawNearestMatchEnabled: rawNearestMatchEnabled,
-                        acceptableInterval: acceptableInterval
-                      }
-                    }]
-                  }
-                }
-              };
-              url = this.url + 'workspaces/' + workspace + '/coveragestores/' + dataStore + '/coverages/' + name + '.json';
-              _context12.next = 1;
-              return (0, _nodeFetch["default"])(url, {
-                credentials: 'include',
-                method: 'PUT',
-                headers: {
-                  Authorization: this.auth,
-                  'Content-Type': 'application/json'
-                },
-                body: JSON.stringify(body)
-              });
-            case 1:
-              response = _context12.sent;
-              if (response.ok) {
-                _context12.next = 3;
-                break;
-              }
-              _context12.next = 2;
-              return (0, _geoserver.getGeoServerResponseText)(response);
-            case 2:
-              geoServerResponse = _context12.sent;
-              throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
-            case 3:
-            case "end":
-              return _context12.stop();
-          }
-        }, _callee12, this);
-      }));
-      function enableTimeCoverage(_x53, _x54, _x55, _x56, _x57, _x58, _x59, _x60, _x61) {
-        return _enableTimeCoverage.apply(this, arguments);
+    }
+    return response.json();
+  }
+
+  /**
+   * Returns a dedicated coverage object.
+   *
+   * @param {String} workspace Workspace containing the coverage
+   * @param {String} name Coverage to query
+   *
+   * @throws Error if request fails
+   *
+   * @returns {Object} An object with coverage information or undefined if it cannot be found
+   */
+  async getCoverageFromLayer(workspace, name) {
+    const url = this.url + '/workspaces/' + workspace + '/coverages/' + name + '.json';
+    const response = await (0, _nodeFetch.default)(url, {
+      credentials: 'include',
+      method: 'GET',
+      headers: {
+        Authorization: this.auth
       }
-      return enableTimeCoverage;
-    }()
-    /**
-     * Enables TIME dimension for the given FeatureType layer.
-     *
-     * @param {String} workspace Workspace containing layer to enable time dimension for
-     * @param {String} datastore The datastore containing the FeatureType to enable time dimension for
-     * @param {String} name FeatureType to enable time dimension for
-     * @param {String} attribute Data column / attribute holding the time values
-     * @param {String} presentation Presentation type: 'LIST' or 'DISCRETE_INTERVAL' or 'CONTINUOUS_INTERVAL'
-     * @param {Number} resolution Resolution in milliseconds, e.g. 3600000 for 1 hour
-     * @param {String} defaultValue The default time value, e.g. 'MINIMUM' or 'MAXIMUM' or 'NEAREST' or 'FIXED'
-     * @param {Boolean} [nearestMatchEnabled] Enable nearest match
-     * @param {Boolean} [rawNearestMatchEnabled] Enable raw nearest match
-     *
-     * @throws Error if request fails
-     */
-    )
-  }, {
-    key: "enableTimeFeatureType",
-    value: (function () {
-      var _enableTimeFeatureType = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee13(workspace, dataStore, name, attribute, presentation, resolution, defaultValue, nearestMatchEnabled, rawNearestMatchEnabled, acceptableInterval) {
-        var body, url, response, geoServerResponse;
-        return _regenerator["default"].wrap(function (_context13) {
-          while (1) switch (_context13.prev = _context13.next) {
-            case 0:
-              body = {
-                featureType: {
-                  metadata: {
-                    entry: [{
-                      '@key': 'time',
-                      dimensionInfo: {
-                        attribute: attribute,
-                        presentation: presentation,
-                        resolution: resolution,
-                        units: 'ISO8601',
-                        defaultValue: {
-                          strategy: defaultValue
-                        },
-                        nearestMatchEnabled: nearestMatchEnabled,
-                        rawNearestMatchEnabled: rawNearestMatchEnabled,
-                        acceptableInterval: acceptableInterval
-                      }
-                    }]
-                  }
-                }
-              };
-              url = this.url + 'workspaces/' + workspace + '/datastores/' + dataStore + '/featuretypes/' + name + '.json';
-              _context13.next = 1;
-              return (0, _nodeFetch["default"])(url, {
-                credentials: 'include',
-                method: 'PUT',
-                headers: {
-                  Authorization: this.auth,
-                  'Content-Type': 'application/json'
-                },
-                body: JSON.stringify(body)
-              });
-            case 1:
-              response = _context13.sent;
-              if (response.ok) {
-                _context13.next = 3;
-                break;
-              }
-              _context13.next = 2;
-              return (0, _geoserver.getGeoServerResponseText)(response);
-            case 2:
-              geoServerResponse = _context13.sent;
-              throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
-            case 3:
-            case "end":
-              return _context13.stop();
-          }
-        }, _callee13, this);
-      }));
-      function enableTimeFeatureType(_x62, _x63, _x64, _x65, _x66, _x67, _x68, _x69, _x70, _x71) {
-        return _enableTimeFeatureType.apply(this, arguments);
+    });
+    if (!response.ok) {
+      const grc = new _about.default(this.url, this.auth);
+      if (await grc.exists()) {
+        // GeoServer exists, but requested item does not exist, we return empty
+        return;
+      } else {
+        // There was a general problem with GeoServer
+        const geoServerResponse = await (0, _geoserver.getGeoServerResponseText)(response);
+        throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
       }
-      return enableTimeFeatureType;
-    }()
-    /**
-     * Returns a dedicated coverage object.
-     *
-     * @param {String} workspace Workspace containing the coverage
-     * @param {String} coverageStore The coveragestore containing the coverage
-     * @param {String} name Coverage to query
-     *
-     * @throws Error if request fails
-     *
-     * @returns {Object} An object with coverage information or undefined if it cannot be found
-     */
-    )
-  }, {
-    key: "getCoverage",
-    value: (function () {
-      var _getCoverage = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee14(workspace, coverageStore, name) {
-        var url, response, grc, geoServerResponse;
-        return _regenerator["default"].wrap(function (_context14) {
-          while (1) switch (_context14.prev = _context14.next) {
-            case 0:
-              url = this.url + 'workspaces/' + workspace + '/coveragestores/' + coverageStore + '/coverages/' + name + '.json';
-              _context14.next = 1;
-              return (0, _nodeFetch["default"])(url, {
-                credentials: 'include',
-                method: 'GET',
-                headers: {
-                  Authorization: this.auth
-                }
-              });
-            case 1:
-              response = _context14.sent;
-              if (response.ok) {
-                _context14.next = 5;
-                break;
-              }
-              grc = new _about["default"](this.url, this.auth);
-              _context14.next = 2;
-              return grc.exists();
-            case 2:
-              if (!_context14.sent) {
-                _context14.next = 3;
-                break;
-              }
-              return _context14.abrupt("return");
-            case 3:
-              _context14.next = 4;
-              return (0, _geoserver.getGeoServerResponseText)(response);
-            case 4:
-              geoServerResponse = _context14.sent;
-              throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
-            case 5:
-              return _context14.abrupt("return", response.json());
-            case 6:
-            case "end":
-              return _context14.stop();
-          }
-        }, _callee14, this);
-      }));
-      function getCoverage(_x72, _x73, _x74) {
-        return _getCoverage.apply(this, arguments);
+    }
+    return response.json();
+  }
+
+  /**
+   * Renames the existing bands of a coverage layer.
+   *
+   * Make sure to provide the same number of bands as existing in the layer.
+   *
+   * @param {String} workspace Workspace of layer
+   * @param {String} datastore The datastore of the layer
+   * @param {String} layername The layer name
+   * @param {String[]} bandNames An array of the new band names in correct order
+   *
+   * @throws Error if request fails
+   */
+  async renameCoverageBands(workspace, dataStore, layername, bandNames) {
+    const body = {
+      coverage: {
+        dimensions: {
+          coverageDimension: []
+        }
       }
-      return getCoverage;
-    }()
-    /**
-     * Returns a dedicated coverage object.
-     *
-     * @param {String} workspace Workspace containing the coverage
-     * @param {String} name Coverage to query
-     *
-     * @throws Error if request fails
-     *
-     * @returns {Object} An object with coverage information or undefined if it cannot be found
-     */
-    )
-  }, {
-    key: "getCoverageFromLayer",
-    value: (function () {
-      var _getCoverageFromLayer = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee15(workspace, name) {
-        var url, response, grc, geoServerResponse;
-        return _regenerator["default"].wrap(function (_context15) {
-          while (1) switch (_context15.prev = _context15.next) {
-            case 0:
-              url = this.url + '/workspaces/' + workspace + '/coverages/' + name + '.json';
-              _context15.next = 1;
-              return (0, _nodeFetch["default"])(url, {
-                credentials: 'include',
-                method: 'GET',
-                headers: {
-                  Authorization: this.auth
-                }
-              });
-            case 1:
-              response = _context15.sent;
-              if (response.ok) {
-                _context15.next = 5;
-                break;
-              }
-              grc = new _about["default"](this.url, this.auth);
-              _context15.next = 2;
-              return grc.exists();
-            case 2:
-              if (!_context15.sent) {
-                _context15.next = 3;
-                break;
-              }
-              return _context15.abrupt("return");
-            case 3:
-              _context15.next = 4;
-              return (0, _geoserver.getGeoServerResponseText)(response);
-            case 4:
-              geoServerResponse = _context15.sent;
-              throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
-            case 5:
-              return _context15.abrupt("return", response.json());
-            case 6:
-            case "end":
-              return _context15.stop();
-          }
-        }, _callee15, this);
-      }));
-      function getCoverageFromLayer(_x75, _x76) {
-        return _getCoverageFromLayer.apply(this, arguments);
+    };
+
+    // dynamically create the body
+    bandNames.forEach(bandName => {
+      body.coverage.dimensions.coverageDimension.push({
+        name: bandName
+      });
+    });
+    const url = this.url + 'workspaces/' + workspace + '/coveragestores/' + dataStore + '/coverages/' + layername + '.json';
+    const response = await (0, _nodeFetch.default)(url, {
+      credentials: 'include',
+      method: 'PUT',
+      headers: {
+        Authorization: this.auth,
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const geoServerResponse = await (0, _geoserver.getGeoServerResponseText)(response);
+      throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
+    }
+  }
+
+  /**
+   * Returns the data store of a layer.
+   *
+   * @param {String} workspace The workspace of the layer
+   * @param {String} layer The name of the layer
+   *
+   * @throws GeoServerResponseError if request fails or layer does not exist or lacks a data store.
+   *
+   * @returns {Object} The data store object
+   */
+  async getDataStore(workspace, layer) {
+    const featureTypeObj = await this.getFeatureTypeFromLayer(workspace, layer);
+    if (!featureTypeObj || !featureTypeObj.featureType || !featureTypeObj.featureType.store || !featureTypeObj.featureType.store.name) {
+      throw new _geoserver.GeoServerResponseError(`Layer '${workspace}:${layer}' lacks a feature type or the feature type lacks a data store.`);
+    }
+    const url = featureTypeObj?.featureType?.store?.href;
+    const response = await (0, _nodeFetch.default)(url, {
+      credentials: 'include',
+      method: 'GET',
+      headers: {
+        Authorization: this.auth
       }
-      return getCoverageFromLayer;
-    }()
-    /**
-     * Renames the existing bands of a coverage layer.
-     *
-     * Make sure to provide the same number of bands as existing in the layer.
-     *
-     * @param {String} workspace Workspace of layer
-     * @param {String} datastore The datastore of the layer
-     * @param {String} layername The layer name
-     * @param {String[]} bandNames An array of the new band names in correct order
-     *
-     * @throws Error if request fails
-     */
-    )
-  }, {
-    key: "renameCoverageBands",
-    value: (function () {
-      var _renameCoverageBands = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee16(workspace, dataStore, layername, bandNames) {
-        var body, url, response, geoServerResponse;
-        return _regenerator["default"].wrap(function (_context16) {
-          while (1) switch (_context16.prev = _context16.next) {
-            case 0:
-              body = {
-                coverage: {
-                  dimensions: {
-                    coverageDimension: []
-                  }
-                }
-              }; // dynamically create the body
-              bandNames.forEach(function (bandName) {
-                body.coverage.dimensions.coverageDimension.push({
-                  name: bandName
-                });
-              });
-              url = this.url + 'workspaces/' + workspace + '/coveragestores/' + dataStore + '/coverages/' + layername + '.json';
-              _context16.next = 1;
-              return (0, _nodeFetch["default"])(url, {
-                credentials: 'include',
-                method: 'PUT',
-                headers: {
-                  Authorization: this.auth,
-                  'Content-Type': 'application/json'
-                },
-                body: JSON.stringify(body)
-              });
-            case 1:
-              response = _context16.sent;
-              if (response.ok) {
-                _context16.next = 3;
-                break;
-              }
-              _context16.next = 2;
-              return (0, _geoserver.getGeoServerResponseText)(response);
-            case 2:
-              geoServerResponse = _context16.sent;
-              throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
-            case 3:
-            case "end":
-              return _context16.stop();
-          }
-        }, _callee16, this);
-      }));
-      function renameCoverageBands(_x77, _x78, _x79, _x80) {
-        return _renameCoverageBands.apply(this, arguments);
+    });
+    if (!response.ok) {
+      const grc = new _about.default(this.url, this.auth);
+      if (await grc.exists()) {
+        // GeoServer exists, but requested item does not exist, we return empty
+        return;
+      } else {
+        // There was a general problem with GeoServer
+        const geoServerResponse = await (0, _geoserver.getGeoServerResponseText)(response);
+        throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
       }
-      return renameCoverageBands;
-    }()
-    /**
-     * Returns the data store of a layer.
-     *
-     * @param {String} workspace The workspace of the layer
-     * @param {String} layer The name of the layer
-     *
-     * @throws GeoServerResponseError if request fails or layer does not exist or lacks a data store.
-     *
-     * @returns {Object} The data store object
-     */
-    )
-  }, {
-    key: "getDataStore",
-    value: (function () {
-      var _getDataStore = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee17(workspace, layer) {
-        var _featureTypeObj$featu;
-        var featureTypeObj, url, response, grc, geoServerResponse;
-        return _regenerator["default"].wrap(function (_context17) {
-          while (1) switch (_context17.prev = _context17.next) {
-            case 0:
-              _context17.next = 1;
-              return this.getFeatureTypeFromLayer(workspace, layer);
-            case 1:
-              featureTypeObj = _context17.sent;
-              if (!(!featureTypeObj || !featureTypeObj.featureType || !featureTypeObj.featureType.store || !featureTypeObj.featureType.store.name)) {
-                _context17.next = 2;
-                break;
-              }
-              throw new _geoserver.GeoServerResponseError("Layer '".concat(workspace, ":").concat(layer, "' lacks a feature type or the feature type lacks a data store."));
-            case 2:
-              url = featureTypeObj === null || featureTypeObj === void 0 || (_featureTypeObj$featu = featureTypeObj.featureType) === null || _featureTypeObj$featu === void 0 || (_featureTypeObj$featu = _featureTypeObj$featu.store) === null || _featureTypeObj$featu === void 0 ? void 0 : _featureTypeObj$featu.href;
-              _context17.next = 3;
-              return (0, _nodeFetch["default"])(url, {
-                credentials: 'include',
-                method: 'GET',
-                headers: {
-                  Authorization: this.auth
-                }
-              });
-            case 3:
-              response = _context17.sent;
-              if (response.ok) {
-                _context17.next = 7;
-                break;
-              }
-              grc = new _about["default"](this.url, this.auth);
-              _context17.next = 4;
-              return grc.exists();
-            case 4:
-              if (!_context17.sent) {
-                _context17.next = 5;
-                break;
-              }
-              return _context17.abrupt("return");
-            case 5:
-              _context17.next = 6;
-              return (0, _geoserver.getGeoServerResponseText)(response);
-            case 6:
-              geoServerResponse = _context17.sent;
-              throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
-            case 7:
-              return _context17.abrupt("return", response.json());
-            case 8:
-            case "end":
-              return _context17.stop();
-          }
-        }, _callee17, this);
-      }));
-      function getDataStore(_x81, _x82) {
-        return _getDataStore.apply(this, arguments);
+    }
+    return response.json();
+  }
+
+  /**
+   * Returns the coverage store of a layer.
+   *
+   * @param {String} workspace The workspace of the layer
+   * @param {String} layer The name of the layer
+   *
+   * @throws GeoServerResponseError if request fails or layer does not exist or lacks a coverage store.
+   *
+   * @returns {Object} The coverage store object
+   */
+  async getCoverageStore(workspace, layer) {
+    const coverageObj = await this.getCoverageFromLayer(workspace, layer);
+    if (!coverageObj || !coverageObj.coverage || !coverageObj.coverage.store || !coverageObj.coverage.store.name) {
+      throw new _geoserver.GeoServerResponseError(`Layer '${workspace}:${layer}' lacks a coverage or the coverage lacks a coverage store.`);
+    }
+    const url = coverageObj?.coverage?.store?.href;
+    const response = await (0, _nodeFetch.default)(url, {
+      credentials: 'include',
+      method: 'GET',
+      headers: {
+        Authorization: this.auth
       }
-      return getDataStore;
-    }()
-    /**
-     * Returns the coverage store of a layer.
-     *
-     * @param {String} workspace The workspace of the layer
-     * @param {String} layer The name of the layer
-     *
-     * @throws GeoServerResponseError if request fails or layer does not exist or lacks a coverage store.
-     *
-     * @returns {Object} The coverage store object
-     */
-    )
-  }, {
-    key: "getCoverageStore",
-    value: (function () {
-      var _getCoverageStore = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee18(workspace, layer) {
-        var _coverageObj$coverage;
-        var coverageObj, url, response, grc, geoServerResponse;
-        return _regenerator["default"].wrap(function (_context18) {
-          while (1) switch (_context18.prev = _context18.next) {
-            case 0:
-              _context18.next = 1;
-              return this.getCoverageFromLayer(workspace, layer);
-            case 1:
-              coverageObj = _context18.sent;
-              if (!(!coverageObj || !coverageObj.coverage || !coverageObj.coverage.store || !coverageObj.coverage.store.name)) {
-                _context18.next = 2;
-                break;
-              }
-              throw new _geoserver.GeoServerResponseError("Layer '".concat(workspace, ":").concat(layer, "' lacks a coverage or the coverage lacks a coverage store."));
-            case 2:
-              url = coverageObj === null || coverageObj === void 0 || (_coverageObj$coverage = coverageObj.coverage) === null || _coverageObj$coverage === void 0 || (_coverageObj$coverage = _coverageObj$coverage.store) === null || _coverageObj$coverage === void 0 ? void 0 : _coverageObj$coverage.href;
-              _context18.next = 3;
-              return (0, _nodeFetch["default"])(url, {
-                credentials: 'include',
-                method: 'GET',
-                headers: {
-                  Authorization: this.auth
-                }
-              });
-            case 3:
-              response = _context18.sent;
-              if (response.ok) {
-                _context18.next = 7;
-                break;
-              }
-              grc = new _about["default"](this.url, this.auth);
-              _context18.next = 4;
-              return grc.exists();
-            case 4:
-              if (!_context18.sent) {
-                _context18.next = 5;
-                break;
-              }
-              return _context18.abrupt("return");
-            case 5:
-              _context18.next = 6;
-              return (0, _geoserver.getGeoServerResponseText)(response);
-            case 6:
-              geoServerResponse = _context18.sent;
-              throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
-            case 7:
-              return _context18.abrupt("return", response.json());
-            case 8:
-            case "end":
-              return _context18.stop();
-          }
-        }, _callee18, this);
-      }));
-      function getCoverageStore(_x83, _x84) {
-        return _getCoverageStore.apply(this, arguments);
+    });
+    if (!response.ok) {
+      const grc = new _about.default(this.url, this.auth);
+      if (await grc.exists()) {
+        // GeoServer exists, but requested item does not exist, we return empty
+        return;
+      } else {
+        // There was a general problem with GeoServer
+        const geoServerResponse = await (0, _geoserver.getGeoServerResponseText)(response);
+        throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
       }
-      return getCoverageStore;
-    }())
-  }]);
-}();
+    }
+    return response.json();
+  }
+}
+exports.default = LayerClient;