geoserver-node-client 0.0.5 → 1.0.0

package/src/style.js

@@ -1,5 +1,7 @@
 import fetch from 'node-fetch';
 import WorkspaceClient from './workspace.js';
+import { getGeoServerResponseText, GeoServerResponseError } from './util/geoserver.js';
+import AboutClient from './about.js'
 
 /**
  * Client for GeoServer styles
@@ -11,41 +13,34 @@ export default class StyleClient {
    * Creates a GeoServer REST StyleClient 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 all default styles.
    *
-   * @returns {Object|Boolean} An object with the default styles or 'false'
+   * @throws Error if request fails
+   *
+   * @returns {Object} An object with the default styles
    */
   async getDefaults () {
-    try {
-      const auth =
-        Buffer.from(this.user + ':' + this.password).toString('base64');
-      const response = await fetch(this.url + 'styles.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 + 'styles.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();
   }
 
   /**
@@ -53,184 +48,242 @@ export default class StyleClient {
    *
    * @param {String} workspace Workspace name to get styles for
    *
-   * @returns {Object|Boolean} An object with all styles or 'false'
+   * @throws Error if request fails
+   *
+   * @returns {Object} An object with all styles
    */
   async getInWorkspace (workspace) {
-    try {
-      const auth =
-        Buffer.from(this.user + ':' + this.password).toString('base64');
-      const response = await fetch(this.url + 'workspaces/' + workspace + '/styles.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 + 'workspaces/' + workspace + '/styles.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();
   }
 
   /**
    * Returns all styles defined in workspaces.
    *
-   * @returns {Object|Boolean} An object with all styles or 'false'
+   * @throws Error if request fails
+   *
+   * @returns {Object[]} An array with all style objects
    */
   async getAllWorkspaceStyles () {
-    try {
-      const allStyles = [];
-      const ws = new WorkspaceClient(this.url, this.user, this.password);
-      const allWs = await ws.getAll();
-
-      // go over all workspaces and query the styles for
-      for (let i = 0; i < allWs.workspaces.workspace.length; i++) {
-        const ws = allWs.workspaces.workspace[i];
-        const wsStyles = await this.getInWorkspace(ws.name);
-
-        if (wsStyles.styles.style) {
-          wsStyles.styles.style.forEach(wsStyle => {
-            allStyles.push(wsStyle);
-          });
-        }
-      }
+    const allStyles = [];
+    const ws = new WorkspaceClient(this.url, this.auth);
+    const allWs = await ws.getAll();
+
+    if (!allWs ||
+      !allWs.workspaces ||
+      !allWs.workspaces.workspace ||
+      !Array.isArray(allWs.workspaces.workspace)) {
+      throw new GeoServerResponseError('Response of available workspaces is malformed');
+    }
+
+    // go over all workspaces and query the styles for
+    for (let i = 0; i < allWs.workspaces.workspace.length; i++) {
+      const ws = allWs.workspaces.workspace[i];
+      const wsStyles = await this.getInWorkspace(ws.name);
 
-      return allStyles;
-    } catch (error) {
-      return false;
+      if (wsStyles.styles.style) {
+        wsStyles.styles.style.forEach(wsStyle => {
+          allStyles.push(wsStyle);
+        });
+      }
     }
+
+    return allStyles;
   }
 
   /**
    * Returns all styles as combined object (default ones and those in
    * workspaces).
    *
-   * @returns {Object|Boolean} An object with all styles or 'false'
+   * @returns {Object[]} An array with all style objects
    */
   async getAll () {
-    try {
-      const defaultStyles = await this.getDefaults();
-      const wsStyles = await this.getAllWorkspaceStyles();
-      const allStyles = defaultStyles.styles.style.concat(wsStyles);
-
-      return allStyles;
-    } catch (error) {
-      return false;
+    const defaultStyles = await this.getDefaults();
+    const wsStyles = await this.getAllWorkspaceStyles();
+    if (
+      !defaultStyles ||
+      !defaultStyles.styles ||
+      !defaultStyles.styles.style ||
+      !Array.isArray(defaultStyles.styles.style)
+    ) {
+      throw new GeoServerResponseError('Response of default styles malformed')
     }
+    const allStyles = defaultStyles.styles.style.concat(wsStyles);
+
+    return allStyles;
   }
 
   /**
    * Publishes a new SLD style.
    *
-   * @param {String} workspace The workspace to publish style in
+   * @param {String} workspace The workspace to publish the style in
    * @param {String} name Name of the style
    * @param {String} sldBody SLD style (as XML text)
    *
-   * @returns {Boolean} If the style could be published
+   * @throws Error if request fails
    */
   async publish (workspace, name, sldBody) {
-    try {
-      const auth = Buffer.from(this.user + ':' + this.password).toString('base64');
-      const response = await fetch(this.url + 'workspaces/' + workspace + '/styles?name=' + name, {
-        credentials: 'include',
-        method: 'POST',
-        headers: {
-          Authorization: 'Basic ' + auth,
-          'Content-Type': 'application/vnd.ogc.sld+xml'
-        },
-        body: sldBody
-      });
-
-      if (response.status === 201) {
-        return true;
-      } else {
-        console.warn(await response.text());
-        return false;
+    const response = await fetch(this.url + 'workspaces/' + workspace + '/styles?name=' + name, {
+      credentials: 'include',
+      method: 'POST',
+      headers: {
+        Authorization: this.auth,
+        'Content-Type': 'application/vnd.ogc.sld+xml'
+      },
+      body: sldBody
+    });
+
+    if (!response.ok) {
+      const geoServerResponse = await getGeoServerResponseText(response);
+      throw new GeoServerResponseError(null, geoServerResponse);
+    }
+  }
+
+  /**
+   * Deletes a style.
+   *
+   * @param {String} workspace The name of the workspace, can be undefined if style is not assigned to a workspace
+   * @param {String} name The name of the style to delete
+   * @param {Boolean} [recurse=false] If references to the specified style in existing layers should be deleted
+   * @param {Boolean} [purge=false] Whether the underlying file containing the style should be deleted on disk
+   */
+  async delete (workspace, name, recurse, purge) {
+    let paramPurge = false;
+    let paramRecurse = false;
+
+    if (purge === true) {
+      paramPurge = true;
+    }
+    if (recurse === true) {
+      paramRecurse = true;
+    }
+
+    let endpoint;
+
+    if (workspace) {
+      // delete style inside workspace
+      endpoint = this.url + 'workspaces/' + workspace + '/styles/' + name +
+                  '?' + 'purge=' + paramPurge + '&' + 'recurse=' + paramRecurse;
+    } else {
+      // delete style without workspace
+      endpoint = this.url + 'styles/' + name +
+                  '?' + 'purge=' + paramPurge + '&' + 'recurse=' + paramRecurse;
+    }
+
+    const response = await fetch(endpoint, {
+      credentials: 'include',
+      method: 'DELETE',
+      headers: {
+        Authorization: this.auth
+      }
+    });
+
+    if (!response.ok) {
+      const geoServerResponse = await getGeoServerResponseText(response);
+      switch (response.status) {
+        case 403:
+          throw new GeoServerResponseError(
+            'Deletion failed. There might be dependant layers to this style. Delete them first or call this with "recurse=false"',
+            geoServerResponse
+          );
+        default:
+          throw new GeoServerResponseError(null, geoServerResponse);
       }
-    } catch (error) {
-      return false;
     }
   }
 
   /**
    * Assigns a style to a layer.
    *
-   * @param {String} qualifiedName GeoServer layer name with workspace prefix
+   * @param {String} workspaceOfLayer The name of the layer's workspace, can be undefined
+   * @param {String} layerName The name of the layer to query
+   * @param {String} workspaceOfStyle The workspace of the style, can be undefined
    * @param {String} styleName The name of the style
-   * @param {String} [workspaceStyle] The workspace of the style
    * @param {Boolean} [isDefaultStyle=true] If the style should be the default style of the layer
    *
-   * @returns {Boolean} If the style could be assigned
+   * @throws Error if request fails
    */
-  async assignStyleToLayer (qualifiedName, styleName, workspaceStyle, isDefaultStyle) {
-    try {
-      const auth = Buffer.from(this.user + ':' + this.password).toString('base64');
-
-      const styleBody = await this.getStyleInformation(styleName, workspaceStyle);
-
-      const response = await fetch(this.url + 'layers/' + qualifiedName + '/styles?default=' + isDefaultStyle, {
-        credentials: 'include',
-        method: 'POST',
-        headers: {
-          Authorization: 'Basic ' + auth,
-          'Content-Type': 'application/json'
-        },
-        body: JSON.stringify(styleBody)
-      });
-
-      if (response.status === 201) {
-        return true;
-      } else {
-        console.warn(await response.text());
-        return false;
-      }
-    } catch (error) {
-      return false;
+  async assignStyleToLayer (workspaceOfLayer, layerName, workspaceOfStyle, styleName, isDefaultStyle) {
+    let qualifiedName;
+    if (workspaceOfLayer) {
+      qualifiedName = `${workspaceOfLayer}:${layerName}`;
+    } else {
+      qualifiedName = layerName;
+    }
+    const styleBody = await this.getStyleInformation(workspaceOfStyle, styleName);
+
+    let url;
+    // we set the style as defaultStyle, unless user explicitly provides 'false'
+    if (isDefaultStyle !== false) {
+      url = this.url + 'layers/' + qualifiedName + '/styles?default=true';
+    } else {
+      url = this.url + 'layers/' + qualifiedName + '/styles';
+    }
+
+    const response = await fetch(url, {
+      credentials: 'include',
+      method: 'POST',
+      headers: {
+        Authorization: this.auth,
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(styleBody)
+    });
+
+    if (!response.ok) {
+      const geoServerResponse = await getGeoServerResponseText(response);
+      throw new GeoServerResponseError(null, geoServerResponse);
     }
   }
 
   /**
    * Get information about a style.
    *
+   * @param {String} workspace The name of the workspace, can be undefined
    * @param {String} styleName The name of the style
-   * @param {String} [workspace] The name of the workspace
    *
-   * @returns {Object|Boolean} An object about the style or 'false'
+   * @throws Error if request fails
+   *
+   * @returns {Object} An object about the style or undefined if it cannot be found
    */
-  async getStyleInformation (styleName, workspace) {
-    try {
-      const auth =
-        Buffer.from(this.user + ':' + this.password).toString('base64');
-
-      let url;
-      if (workspace) {
-        url = this.url + 'workspaces/' + workspace + '/styles/' + styleName + '.json';
-      } else {
-        url = this.url + 'styles/' + styleName + '.json';
-      }
+  async getStyleInformation (workspace, styleName) {
+    let url;
+    if (workspace) {
+      url = this.url + 'workspaces/' + workspace + '/styles/' + styleName + '.json';
+    } else {
+      url = this.url + 'styles/' + styleName + '.json';
+    }
 
-      const response = await fetch(url, {
-        credentials: 'include',
-        method: 'GET',
-        headers: {
-          Authorization: 'Basic ' + auth
-        }
-      });
+    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();
   }
 }

package/src/util/geoserver.js

@@ -0,0 +1,41 @@
+/**
+ * Utility functions and classes
+ */
+
+/**
+ * Return the GeoServer response text if available.
+ *
+ * @param {Response} response The response of the GeoServer
+ *
+ * @returns {String} The response text if available
+ */
+async function getGeoServerResponseText (response) {
+  try {
+    return response.text()
+  } catch (e) {
+    // return nothing
+  }
+}
+
+/**
+ * Generic GeoServer error
+ */
+class GeoServerResponseError extends Error {
+  /**
+   * @param {String} [message=GeoServer Response Error] The error message
+   * @param {String} [geoServerOutput] The error output from GeoServer (useful for debugging)
+   */
+  constructor (message, geoServerOutput) {
+    super(message)
+    this.name = 'GeoServerResponseError';
+    this.message = message || 'GeoServer Response Error'
+
+    // custom property as explained here: https://xjamundx.medium.com/custom-javascript-errors-in-es6-aa891b173f87
+    this.geoServerOutput = geoServerOutput;
+  }
+}
+
+export {
+  getGeoServerResponseText,
+  GeoServerResponseError
+}