geoserver-node-client 0.0.5 → 1.0.0

package/src/layer.js

@@ -1,4 +1,6 @@
 import fetch from 'node-fetch';
+import { getGeoServerResponseText, GeoServerResponseError } from './util/geoserver.js';
+import AboutClient from './about.js'
 
 /**
  * Client for GeoServer layers
@@ -10,116 +12,125 @@ export default class LayerClient {
    * Creates a GeoServer REST LayerClient instance.
    *
    * @param {String} url The URL of the GeoServer REST API endpoint
-   * @param {String} user The user for the GeoServer REST API
-   * @param {String} password The password for the GeoServer REST API
+   * @param {String} auth The Basic Authentication string
    */
-  constructor (url, user, password) {
-    this.url = url.endsWith('/') ? url : url + '/';
-    this.user = user;
-    this.password = password;
+  constructor (url, auth) {
+    this.url = url;
+    this.auth = auth;
   }
 
   /**
-   * Returns a GeoServer layer by the given full qualified layer name,
+   * Returns a GeoServer layer by the given workspace and layer name,
    * e.g. "myWs:myLayer".
    *
-   * @param {String} qualifiedName GeoServer layer name with workspace prefix
+   * @param {String} workspace The name of the workspace, can be undefined
+   * @param {String} layerName The name of the layer to query
    *
-   * @returns {Object|Boolean} An object with layer information or 'false'
+   * @throws Error if request fails
+   *
+   * @returns {Object} An object with layer information or undefined if it cannot be found
    */
-  async get (qualifiedName) {
-    try {
-      const auth = Buffer.from(this.user + ':' + this.password).toString('base64');
-      const response = await fetch(this.url + 'layers/' + qualifiedName + '.json', {
-        credentials: 'include',
-        method: 'GET',
-        headers: {
-          Authorization: 'Basic ' + auth
-        }
-      });
+  async get (workspace, layerName) {
+    let qualifiedName;
+    if (workspace) {
+      qualifiedName = `${workspace}:${layerName}`;
+    } else {
+      qualifiedName = layerName;
+    }
+    const response = await fetch(this.url + 'layers/' + qualifiedName + '.json', {
+      credentials: 'include',
+      method: 'GET',
+      headers: {
+        Authorization: this.auth
+      }
+    });
 
-      if (response.status === 200) {
-        return await response.json();
+    if (!response.ok) {
+      const grc = new AboutClient(this.url, this.auth);
+      if (await grc.exists()) {
+        // GeoServer exists, but requested item does not exist,  we return empty
+        return;
       } else {
-        console.warn(await response.text());
-        return false;
+        // There was a general problem with GeoServer
+        const geoServerResponse = await getGeoServerResponseText(response);
+        throw new GeoServerResponseError(null, geoServerResponse);
       }
-    } catch (error) {
-      return false;
     }
+    return response.json();
   }
 
   /**
    * Sets the attribution text and link of a layer.
    *
-   * @param {String} qualifiedName GeoServer layer name with workspace prefix
+   * @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
    *
-   * @returns {Boolean} If attribution could be updated
+   * @throws Error if request fails
    */
-  async modifyAttribution (qualifiedName, attributionText, attributionLink) {
-    try {
-      // take existing layer properties as template
-      const jsonBody = await this.get(qualifiedName);
-
-      // set attribution text and link
-      if (attributionText) {
-        jsonBody.layer.attribution.title = attributionText;
-      }
-      if (attributionLink) {
-        jsonBody.layer.attribution.href = attributionLink;
-      }
+  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);
 
-      const auth = Buffer.from(this.user + ':' + this.password).toString('base64');
-      const url = this.url + 'layers/' + qualifiedName + '.json';
-      const response = await fetch(url, {
-        credentials: 'include',
-        method: 'PUT',
-        headers: {
-          Authorization: 'Basic ' + auth,
-          'Content-Type': 'application/json'
-        },
-        body: JSON.stringify(jsonBody)
-      });
-
-      if (response.status === 200) {
-        return true;
-      } else {
-        console.warn(await response.text());
-        return false;
-      }
-    } catch (error) {
-      console.log(error);
-      return false;
+    if (!jsonBody || !jsonBody.layer || !jsonBody.layer.attribution) {
+      throw new 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 fetch(url, {
+      credentials: 'include',
+      method: 'PUT',
+      headers: {
+        Authorization: this.auth,
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(jsonBody)
+    });
+
+    if (!response.ok) {
+      const geoServerResponse = await getGeoServerResponseText(response);
+      throw new GeoServerResponseError(null, geoServerResponse);
     }
   }
 
   /**
    * Returns all layers in the GeoServer.
    *
-   * @returns {Object|Boolean} An object with all layer information or 'false'
+   * @throws Error if request fails
+   *
+   * @returns {Object} An object with all layer information
    */
   async getAll () {
-    try {
-      const auth = Buffer.from(this.user + ':' + this.password).toString('base64');
-      const response = await fetch(this.url + 'layers.json', {
-        credentials: 'include',
-        method: 'GET',
-        headers: {
-          Authorization: 'Basic ' + auth
-        }
-      });
-
-      if (response.status === 200) {
-        return await response.json();
-      } else {
-        console.warn(await response.text());
-        return false;
+    const response = await fetch(this.url + 'layers.json', {
+      credentials: 'include',
+      method: 'GET',
+      headers: {
+        Authorization: this.auth
       }
-    } catch (error) {
-      return false;
+    });
+
+    if (!response.ok) {
+      const geoServerResponse = await getGeoServerResponseText(response);
+      throw new GeoServerResponseError(null, geoServerResponse);
     }
+    return response.json();
   }
 
   /**
@@ -133,40 +144,33 @@ export default class LayerClient {
    * @param {String} enabled Flag to enable FeatureType by default
    * @param {String} [abstract] The abstract of the layer
    *
-   * @returns {Boolean} If FeatureType could be published.
+   * @throws Error if request fails
    */
   async publishFeatureTypeDefaultDataStore (workspace, nativeName, name, title, srs, enabled, abstract) {
-    try {
-      const body = {
-        featureType: {
-          name: name,
-          nativeName: name,
-          title: title || name,
-          srs: srs || 'EPSG:4326',
-          enabled: enabled,
-          abstract: abstract || ''
-        }
-      };
-
-      const auth = Buffer.from(this.user + ':' + this.password).toString('base64');
-      const response = await fetch(this.url + 'workspaces/' + workspace + '/featuretypes', {
-        credentials: 'include',
-        method: 'POST',
-        headers: {
-          Authorization: 'Basic ' + auth,
-          'Content-Type': 'application/json'
-        },
-        body: JSON.stringify(body)
-      });
-
-      if (response.status === 201) {
-        return true;
-      } else {
-        console.warn(await response.text());
-        return false;
+    const body = {
+      featureType: {
+        name: name,
+        nativeName: nativeName || name,
+        title: title || name,
+        srs: srs || 'EPSG:4326',
+        enabled: enabled,
+        abstract: abstract || ''
       }
-    } catch (error) {
-      return false;
+    };
+
+    const response = await fetch(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 getGeoServerResponseText(response);
+      throw new GeoServerResponseError(null, geoServerResponse);
     }
   }
 
@@ -183,50 +187,78 @@ export default class LayerClient {
    * @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)
    *
-   * @returns {Boolean} If the FeatureType could be published
+   * @throws Error if request fails
    */
   async publishFeatureType (workspace, dataStore, nativeName, name, title, srs, enabled, abstract, nativeBoundingBox) {
-    try {
-      // apply CRS info for native BBOX if not provided
-      if (nativeBoundingBox && !nativeBoundingBox.crs) {
-        nativeBoundingBox.crs = {
-          '@class': 'projected',
-          $: srs
-        }
+    // 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 auth = Buffer.from(this.user + ':' + this.password).toString('base64');
-      const response = await fetch(this.url + 'workspaces/' + workspace + '/datastores/' + dataStore + '/featuretypes', {
-        credentials: 'include',
-        method: 'POST',
-        headers: {
-          Authorization: 'Basic ' + auth,
-          'Content-Type': 'application/json'
-        },
-        body: JSON.stringify(body)
-      });
-
-      if (response.status === 201) {
-        return true;
+    const body = {
+      featureType: {
+        name: name || nativeName,
+        nativeName: nativeName,
+        title: title || name,
+        srs: srs || 'EPSG:4326',
+        enabled: enabled,
+        abstract: abstract || '',
+        nativeBoundingBox: nativeBoundingBox
+      }
+    };
+
+    const response = await fetch(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 getGeoServerResponseText(response);
+      throw new 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 fetch(url, {
+      credentials: 'include',
+      method: 'GET',
+      headers: {
+        Authorization: this.auth
+      }
+    });
+
+    if (!response.ok) {
+      const grc = new AboutClient(this.url, this.auth);
+      if (await grc.exists()) {
+        // GeoServer exists, but requested item does not exist, we return empty
+        return;
       } else {
-        console.warn(await response.text());
-        return false;
+        // There was a general problem with GeoServer
+        const geoServerResponse = await getGeoServerResponseText(response);
+        throw new GeoServerResponseError(null, geoServerResponse);
       }
-    } catch (error) {
-      return false;
     }
+    return response.json();
   }
 
   /**
@@ -241,40 +273,33 @@ export default class LayerClient {
    * @param {String} enabled Flag to enable WMS layer by default
    * @param {String} [abstract] The abstract of the layer
    *
-   * @returns {Boolean} If the wms layer could be published
+   * @throws Error if request fails
    */
   async publishWmsLayer (workspace, dataStore, nativeName, name, title, srs, enabled, abstract) {
-    try {
-      const body = {
-        wmsLayer: {
-          name: name || nativeName,
-          nativeName: nativeName,
-          title: title || name || nativeName,
-          srs: srs || 'EPSG:4326',
-          enabled: enabled,
-          abstract: abstract || ''
-        }
-      };
-
-      const auth = Buffer.from(this.user + ':' + this.password).toString('base64');
-      const response = await fetch(this.url + 'workspaces/' + workspace + '/wmsstores/' + dataStore + '/wmslayers', {
-        credentials: 'include',
-        method: 'POST',
-        headers: {
-          Authorization: 'Basic ' + auth,
-          'Content-Type': 'application/json'
-        },
-        body: JSON.stringify(body)
-      });
-
-      if (response.status === 201) {
-        return true;
-      } else {
-        console.warn(await response.text());
-        return false;
+    const body = {
+      wmsLayer: {
+        name: name || nativeName,
+        nativeName: nativeName,
+        title: title || name || nativeName,
+        srs: srs || 'EPSG:4326',
+        enabled: enabled,
+        abstract: abstract || ''
       }
-    } catch (error) {
-      return false;
+    };
+
+    const response = await fetch(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 getGeoServerResponseText(response);
+      throw new GeoServerResponseError(null, geoServerResponse);
     }
   }
 
@@ -290,39 +315,33 @@ export default class LayerClient {
    * @param {String} enabled Flag to enable layer by default
    * @param {String} [abstract] The abstract of the layer
    *
-   * @returns {Boolean} If raster could be published
+   * @throws Error if request fails
    */
   async publishDbRaster (workspace, coverageStore, nativeName, name, title, srs, enabled, abstract) {
-    try {
-      const body = {
-        coverage: {
-          name: name || nativeName,
-          nativeName: nativeName,
-          title: title || name,
-          srs: srs,
-          enabled: enabled,
-          abstract: abstract || ''
-        }
-      };
-
-      const auth = Buffer.from(this.user + ':' + this.password).toString('base64');
-      const response = await fetch(this.url + 'workspaces/' + workspace + '/coveragestores/' + coverageStore + '/coverages', {
-        credentials: 'include',
-        method: 'POST',
-        headers: {
-          Authorization: 'Basic ' + auth,
-          'Content-Type': 'application/json'
-        },
-        body: JSON.stringify(body)
-      });
-
-      if (response.status === 201) {
-        return true;
-      } else {
-        return false;
+    const body = {
+      coverage: {
+        name: name || nativeName,
+        nativeName: nativeName,
+        title: title || name,
+        srs: srs,
+        enabled: enabled,
+        abstract: abstract || ''
       }
-    } catch (error) {
-      return false;
+    };
+
+    const response = await fetch(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 getGeoServerResponseText(response);
+      throw new GeoServerResponseError(null, geoServerResponse);
     }
   }
 
@@ -334,27 +353,20 @@ export default class LayerClient {
    * @param {String} name Layer to delete
    * @param {Boolean} recurse Flag to enable recursive deletion
    *
-   * @returns {Boolean} If the feature type could be deleted
+   * @throws Error if request fails
    */
   async deleteFeatureType (workspace, datastore, name, recurse) {
-    try {
-      const auth = Buffer.from(this.user + ':' + this.password).toString('base64');
-      const response = await fetch(this.url + 'workspaces/' + workspace + '/datastores/' + datastore + '/featuretypes/' + name + '?recurse=' + recurse, {
-        credentials: 'include',
-        method: 'DELETE',
-        headers: {
-          Authorization: 'Basic ' + auth
-        }
-      });
-
-      if (response.status === 200) {
-        return true;
-      } else {
-        console.warn(await response.text());
-        return false;
+    const response = await fetch(this.url + 'workspaces/' + workspace + '/datastores/' + datastore + '/featuretypes/' + name + '?recurse=' + recurse, {
+      credentials: 'include',
+      method: 'DELETE',
+      headers: {
+        Authorization: this.auth
       }
-    } catch (error) {
-      return false;
+    });
+
+    if (!response.ok) {
+      const geoServerResponse = await getGeoServerResponseText(response);
+      throw new GeoServerResponseError(null, geoServerResponse);
     }
   }
 
@@ -371,56 +383,46 @@ export default class LayerClient {
    * @param {Boolean} [rawNearestMatchEnabled] Enable raw nearest match
    * @param {String} [acceptableInterval] Acceptable interval for nearest match, e.g.'PT30M'
    *
-   * @returns If time dimension could be enabled
+   * @throws Error if request fails
    */
   async enableTimeCoverage (workspace, dataStore, name, presentation, resolution, defaultValue, nearestMatchEnabled, rawNearestMatchEnabled, acceptableInterval) {
-    try {
-      const body = {
-        coverage: {
-          metadata: {
-            entry: [
-              {
-                '@key': 'time',
-                dimensionInfo: {
-                  enabled: true,
-                  presentation: 'DISCRETE_INTERVAL',
-                  resolution: resolution,
-                  units: 'ISO8601',
-                  defaultValue: {
-                    strategy: defaultValue
-                  },
-                  nearestMatchEnabled: nearestMatchEnabled,
-                  rawNearestMatchEnabled: rawNearestMatchEnabled,
-                  acceptableInterval: acceptableInterval
-                }
+    const body = {
+      coverage: {
+        metadata: {
+          entry: [
+            {
+              '@key': 'time',
+              dimensionInfo: {
+                presentation: presentation || 'DISCRETE_INTERVAL',
+                resolution: resolution,
+                units: 'ISO8601',
+                defaultValue: {
+                  strategy: defaultValue
+                },
+                nearestMatchEnabled: nearestMatchEnabled,
+                rawNearestMatchEnabled: rawNearestMatchEnabled,
+                acceptableInterval: acceptableInterval
               }
-            ]
-          }
+            }
+          ]
         }
-      };
-
-      const auth = Buffer.from(this.user + ':' + this.password).toString('base64');
-      const url = this.url + 'workspaces/' + workspace + '/coveragestores/' + dataStore + '/coverages/' + name + '.json';
-      console.log(url);
-      const response = await fetch(url, {
-        credentials: 'include',
-        method: 'PUT',
-        headers: {
-          Authorization: 'Basic ' + auth,
-          'Content-Type': 'application/json'
-        },
-        body: JSON.stringify(body)
-      });
-
-      if (response.status === 200) {
-        return true;
-      } else {
-        console.warn(await response.text());
-        return false;
       }
-    } catch (error) {
-      console.log(error);
-      return false;
+    };
+
+    const url = this.url + 'workspaces/' + workspace + '/coveragestores/' + dataStore + '/coverages/' + name + '.json';
+    const response = await fetch(url, {
+      credentials: 'include',
+      method: 'PUT',
+      headers: {
+        Authorization: this.auth,
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(body)
+    });
+
+    if (!response.ok) {
+      const geoServerResponse = await getGeoServerResponseText(response);
+      throw new GeoServerResponseError(null, geoServerResponse);
     }
   }
 
@@ -436,57 +438,48 @@ export default class LayerClient {
    * @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] Tolerance interval for nearest mach (e.g. 'PT30M'), only has an effect if 'nearestMatchEnabled' is true
    *
-   * @returns {Boolean} If TIME dimension could be enabled
+   * @throws Error if request fails
    */
   async enableTimeFeatureType (workspace, dataStore, name, attribute, presentation, resolution, defaultValue, nearestMatchEnabled, rawNearestMatchEnabled, acceptableInterval) {
-    try {
-      const body = {
-        featureType: {
-          metadata: {
-            entry: [
-              {
-                '@key': 'time',
-                dimensionInfo: {
-                  enabled: true,
-                  attribute: attribute,
-                  presentation: presentation,
-                  resolution: resolution,
-                  units: 'ISO8601',
-                  defaultValue: {
-                    strategy: defaultValue
-                  },
-                  nearestMatchEnabled: nearestMatchEnabled,
-                  rawNearestMatchEnabled: rawNearestMatchEnabled,
-                  acceptableInterval: 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
               }
-            ]
-          }
+            }
+          ]
         }
-      };
-
-      const auth = Buffer.from(this.user + ':' + this.password).toString('base64');
-      const url = this.url + 'workspaces/' + workspace + '/datastores/' + dataStore + '/featuretypes/' + name + '.json';
-      const response = await fetch(url, {
-        credentials: 'include',
-        method: 'PUT',
-        headers: {
-          Authorization: 'Basic ' + auth,
-          'Content-Type': 'application/json'
-        },
-        body: JSON.stringify(body)
-      });
-
-      if (response.status === 200) {
-        return true;
-      } else {
-        console.warn(await response.text());
-        return false;
       }
-    } catch (error) {
-      return false;
+    };
+
+    const url = this.url + 'workspaces/' + workspace + '/datastores/' + dataStore + '/featuretypes/' + name + '.json';
+    const response = await fetch(url, {
+      credentials: 'include',
+      method: 'PUT',
+      headers: {
+        Authorization: this.auth,
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(body)
+    });
+
+    if (!response.ok) {
+      const geoServerResponse = await getGeoServerResponseText(response);
+      throw new GeoServerResponseError(null, geoServerResponse);
     }
   }
 
@@ -497,28 +490,79 @@ export default class LayerClient {
    * @param {String} coverageStore The coveragestore containing the coverage
    * @param {String} name Coverage to query
    *
-   * @returns {Object|Boolean} An object with coverage information or 'false'
+   * @throws Error if request fails
+   *
+   * @returns {Object} An object with coverage information or undefined if it cannot be found
    */
   async getCoverage (workspace, coverageStore, name) {
-    try {
-      const auth = Buffer.from(this.user + ':' + this.password).toString('base64');
-      const url = this.url + 'workspaces/' + workspace + '/coveragestores/' + coverageStore + '/coverages/' + name + '.json';
-      const response = await fetch(url, {
-        credentials: 'include',
-        method: 'GET',
-        headers: {
-          Authorization: 'Basic ' + auth
-        }
-      });
+    const url = this.url + 'workspaces/' + workspace + '/coveragestores/' + coverageStore + '/coverages/' + name + '.json';
+    const response = await fetch(url, {
+      credentials: 'include',
+      method: 'GET',
+      headers: {
+        Authorization: this.auth
+      }
+    });
 
-      if (response.status === 200) {
-        return await response.json();
+    if (!response.ok) {
+      const grc = new AboutClient(this.url, this.auth);
+      if (await grc.exists()) {
+        // GeoServer exists, but requested item does not exist,  we return empty
+        return;
       } else {
-        console.warn(await response.text());
-        return false;
+        // There was a general problem with GeoServer
+        const geoServerResponse = await getGeoServerResponseText(response);
+        throw new GeoServerResponseError(null, geoServerResponse);
       }
-    } catch (error) {
-      return false;
+    }
+    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: [
+          ]
+        }
+      }
+    };
+
+    // 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 fetch(url, {
+      credentials: 'include',
+      method: 'PUT',
+      headers: {
+        Authorization: this.auth,
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(body)
+    });
+
+    if (!response.ok) {
+      const geoServerResponse = await getGeoServerResponseText(response);
+      throw new GeoServerResponseError(null, geoServerResponse);
     }
   }
 }