geoserver-node-client 1.4.8 → 1.5.1

package/src/layer.js

@@ -1,6 +1,6 @@
 import fetch from 'node-fetch';
 import { getGeoServerResponseText, GeoServerResponseError } from './util/geoserver.js';
-import AboutClient from './about.js'
+import AboutClient from './about.js';
 
 /**
  * Client for GeoServer layers
@@ -14,7 +14,7 @@ export default class LayerClient {
    * @param {String} url The URL of the GeoServer REST API endpoint
    * @param {String} auth The Basic Authentication string
    */
-  constructor (url, auth) {
+  constructor(url, auth) {
     this.url = url;
     this.auth = auth;
   }
@@ -30,7 +30,7 @@ export default class LayerClient {
    *
    * @returns {Object} An object with layer information or undefined if it cannot be found
    */
-  async get (workspace, layerName) {
+  async get(workspace, layerName) {
     let qualifiedName;
     if (workspace) {
       qualifiedName = `${workspace}:${layerName}`;
@@ -69,7 +69,7 @@ export default class LayerClient {
    *
    * @throws Error if request fails
    */
-  async modifyAttribution (workspace, layerName, attributionText, attributionLink) {
+  async modifyAttribution(workspace, layerName, attributionText, attributionLink) {
     let qualifiedName;
     if (workspace) {
       qualifiedName = `${workspace}:${layerName}`;
@@ -117,7 +117,7 @@ export default class LayerClient {
    *
    * @returns {Object} An object with all layer information
    */
-  async getAll () {
+  async getAll() {
     const response = await fetch(this.url + 'layers.json', {
       credentials: 'include',
       method: 'GET',
@@ -142,12 +142,12 @@ export default class LayerClient {
    *
    * @return {Object} An object with the information about the layers
    */
-  async getLayers (workspace) {
+  async getLayers(workspace) {
     const response = await fetch(this.url + 'workspaces/' + workspace + '/layers.json', {
       credentials: 'include',
       method: 'GET',
       headers: {
-        Authorization: this.auth,
+        Authorization: this.auth
       }
     });
 
@@ -170,14 +170,24 @@ export default class LayerClient {
    *
    * @returns {Object} An object with layer information or undefined if it cannot be found
    */
-  async getWmsLayer (workspace, datastore, layerName) {
-    const response = await fetch(this.url + 'workspaces/' + workspace + '/wmsstores/' + datastore + '/wmslayers/' + layerName + '.json', {
-      credentials: 'include',
-      method: 'GET',
-      headers: {
-        Authorization: this.auth,
+  async getWmsLayer(workspace, datastore, layerName) {
+    const response = await fetch(
+      this.url +
+        'workspaces/' +
+        workspace +
+        '/wmsstores/' +
+        datastore +
+        '/wmslayers/' +
+        layerName +
+        '.json',
+      {
+        credentials: 'include',
+        method: 'GET',
+        headers: {
+          Authorization: this.auth
+        }
       }
-    });
+    );
 
     if (!response.ok) {
       const grc = new AboutClient(this.url, this.auth);
@@ -206,14 +216,24 @@ export default class LayerClient {
    *
    * @returns {Object} An object with layer information or undefined if it cannot be found
    */
-   async getWmtsLayer (workspace, datastore, layerName) {
-    const response = await fetch(this.url + 'workspaces/' + workspace + '/wmtsstores/' + datastore + '/layers/' + layerName + '.json', {
-      credentials: 'include',
-      method: 'GET',
-      headers: {
-        Authorization: this.auth,
+  async getWmtsLayer(workspace, datastore, layerName) {
+    const response = await fetch(
+      this.url +
+        'workspaces/' +
+        workspace +
+        '/wmtsstores/' +
+        datastore +
+        '/layers/' +
+        layerName +
+        '.json',
+      {
+        credentials: 'include',
+        method: 'GET',
+        headers: {
+          Authorization: this.auth
+        }
       }
-    });
+    );
 
     if (!response.ok) {
       const grc = new AboutClient(this.url, this.auth);
@@ -243,7 +263,15 @@ export default class LayerClient {
    *
    * @throws Error if request fails
    */
-  async publishFeatureTypeDefaultDataStore (workspace, nativeName, name, title, srs, enabled, abstract) {
+  async publishFeatureTypeDefaultDataStore(
+    workspace,
+    nativeName,
+    name,
+    title,
+    srs,
+    enabled,
+    abstract
+  ) {
     const body = {
       featureType: {
         name: name,
@@ -286,13 +314,23 @@ export default class LayerClient {
    *
    * @throws Error if request fails
    */
-  async publishFeatureType (workspace, dataStore, nativeName, name, title, srs, enabled, abstract, nativeBoundingBox) {
+  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 = {
@@ -307,15 +345,18 @@ export default class LayerClient {
       }
     };
 
-    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)
-    });
+    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);
@@ -334,8 +375,16 @@ export default class LayerClient {
    *
    * @returns {Object} The object of the FeatureType
    */
-  async getFeatureType (workspace, datastore, name) {
-    const url = this.url + 'workspaces/' + workspace + '/datastores/' + datastore + '/featuretypes/' + name + '.json';
+  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',
@@ -358,6 +407,42 @@ export default class LayerClient {
     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 GeoServerResponseError(
+        `Layer '${workspace}:${layer}' does not exist or lacks the layer.resource.href property.`
+      );
+    }
+
+    const url = layerObj?.layer?.resource?.href;
+
+    const response = await fetch(url, {
+      credentials: 'include',
+      method: 'GET',
+      headers: {
+        Authorization: this.auth
+      }
+    });
+
+    if (!response.ok) {
+      const geoServerResponse = await getGeoServerResponseText(response);
+      throw new GeoServerResponseError(null, geoServerResponse);
+    }
+    return response.json();
+  }
+
   /**
    *  Publishes a WMS layer.
    *
@@ -372,7 +457,7 @@ export default class LayerClient {
    *
    * @throws Error if request fails
    */
-  async publishWmsLayer (workspace, dataStore, nativeName, name, title, srs, enabled, abstract) {
+  async publishWmsLayer(workspace, dataStore, nativeName, name, title, srs, enabled, abstract) {
     const body = {
       wmsLayer: {
         name: name || nativeName,
@@ -384,15 +469,18 @@ export default class LayerClient {
       }
     };
 
-    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)
-    });
+    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);
@@ -414,7 +502,7 @@ export default class LayerClient {
    *
    * @throws Error if request fails
    */
-  async publishDbRaster (workspace, coverageStore, nativeName, name, title, srs, enabled, abstract) {
+  async publishDbRaster(workspace, coverageStore, nativeName, name, title, srs, enabled, abstract) {
     const body = {
       coverage: {
         name: name || nativeName,
@@ -426,15 +514,18 @@ export default class LayerClient {
       }
     };
 
-    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)
-    });
+    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);
@@ -452,14 +543,25 @@ export default class LayerClient {
    *
    * @throws Error if request fails
    */
-  async deleteFeatureType (workspace, datastore, name, recurse) {
-    const response = await fetch(this.url + 'workspaces/' + workspace + '/datastores/' + datastore + '/featuretypes/' + name + '?recurse=' + recurse, {
-      credentials: 'include',
-      method: 'DELETE',
-      headers: {
-        Authorization: this.auth
+  async deleteFeatureType(workspace, datastore, name, recurse) {
+    const response = await fetch(
+      this.url +
+        'workspaces/' +
+        workspace +
+        '/datastores/' +
+        datastore +
+        '/featuretypes/' +
+        name +
+        '?recurse=' +
+        recurse,
+      {
+        credentials: 'include',
+        method: 'DELETE',
+        headers: {
+          Authorization: this.auth
+        }
       }
-    });
+    );
 
     if (!response.ok) {
       const geoServerResponse = await getGeoServerResponseText(response);
@@ -482,7 +584,17 @@ export default class LayerClient {
    *
    * @throws Error if request fails
    */
-  async enableTimeCoverage (workspace, dataStore, name, presentation, resolution, defaultValue, nearestMatchEnabled, rawNearestMatchEnabled, acceptableInterval) {
+  async enableTimeCoverage(
+    workspace,
+    dataStore,
+    name,
+    presentation,
+    resolution,
+    defaultValue,
+    nearestMatchEnabled,
+    rawNearestMatchEnabled,
+    acceptableInterval
+  ) {
     const body = {
       coverage: {
         metadata: {
@@ -507,7 +619,15 @@ export default class LayerClient {
       }
     };
 
-    const url = this.url + 'workspaces/' + workspace + '/coveragestores/' + dataStore + '/coverages/' + name + '.json';
+    const url =
+      this.url +
+      'workspaces/' +
+      workspace +
+      '/coveragestores/' +
+      dataStore +
+      '/coverages/' +
+      name +
+      '.json';
     const response = await fetch(url, {
       credentials: 'include',
       method: 'PUT',
@@ -539,7 +659,18 @@ export default class LayerClient {
    *
    * @throws Error if request fails
    */
-  async enableTimeFeatureType (workspace, dataStore, name, attribute, presentation, resolution, defaultValue, nearestMatchEnabled, rawNearestMatchEnabled, acceptableInterval) {
+  async enableTimeFeatureType(
+    workspace,
+    dataStore,
+    name,
+    attribute,
+    presentation,
+    resolution,
+    defaultValue,
+    nearestMatchEnabled,
+    rawNearestMatchEnabled,
+    acceptableInterval
+  ) {
     const body = {
       featureType: {
         metadata: {
@@ -564,7 +695,15 @@ export default class LayerClient {
       }
     };
 
-    const url = this.url + 'workspaces/' + workspace + '/datastores/' + dataStore + '/featuretypes/' + name + '.json';
+    const url =
+      this.url +
+      'workspaces/' +
+      workspace +
+      '/datastores/' +
+      dataStore +
+      '/featuretypes/' +
+      name +
+      '.json';
     const response = await fetch(url, {
       credentials: 'include',
       method: 'PUT',
@@ -592,8 +731,16 @@ export default class LayerClient {
    *
    * @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';
+  async getCoverage(workspace, coverageStore, name) {
+    const url =
+      this.url +
+      'workspaces/' +
+      workspace +
+      '/coveragestores/' +
+      coverageStore +
+      '/coverages/' +
+      name +
+      '.json';
     const response = await fetch(url, {
       credentials: 'include',
       method: 'GET',
@@ -616,6 +763,40 @@ export default class LayerClient {
     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 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 {
+        // There was a general problem with GeoServer
+        const geoServerResponse = await getGeoServerResponseText(response);
+        throw new GeoServerResponseError(null, geoServerResponse);
+      }
+    }
+    return response.json();
+  }
+
   /**
    * Renames the existing bands of a coverage layer.
    *
@@ -628,26 +809,31 @@ export default class LayerClient {
    *
    * @throws Error if request fails
    */
-  async renameCoverageBands (workspace, dataStore, layername, bandNames) {
+  async renameCoverageBands(workspace, dataStore, layername, bandNames) {
     const body = {
       coverage: {
         dimensions: {
-          coverageDimension: [
-          ]
+          coverageDimension: []
         }
       }
     };
 
     // dynamically create the body
-    bandNames.forEach(bandName => {
-      body.coverage.dimensions.coverageDimension.push(
-        {
-          name: bandName
-        }
-      );
-    })
+    bandNames.forEach((bandName) => {
+      body.coverage.dimensions.coverageDimension.push({
+        name: bandName
+      });
+    });
 
-    const url = this.url + 'workspaces/' + workspace + '/coveragestores/' + dataStore + '/coverages/' + layername + '.json';
+    const url =
+      this.url +
+      'workspaces/' +
+      workspace +
+      '/coveragestores/' +
+      dataStore +
+      '/coverages/' +
+      layername +
+      '.json';
     const response = await fetch(url, {
       credentials: 'include',
       method: 'PUT',
@@ -663,4 +849,100 @@ export default class LayerClient {
       throw new 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 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 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 {
+        // There was a general problem with GeoServer
+        const geoServerResponse = await getGeoServerResponseText(response);
+        throw new GeoServerResponseError(null, geoServerResponse);
+      }
+    }
+    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 GeoServerResponseError(
+        `Layer '${workspace}:${layer}' lacks a coverage or the coverage lacks a coverage store.`
+      );
+    }
+
+    const url = coverageObj?.coverage?.store?.href;
+
+    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 {
+        // There was a general problem with GeoServer
+        const geoServerResponse = await getGeoServerResponseText(response);
+        throw new GeoServerResponseError(null, geoServerResponse);
+      }
+    }
+    return response.json();
+  }
 }