geoserver-node-client 0.0.7 → 1.2.0

package/src/namespace.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 namespace
@@ -10,36 +12,33 @@ export default class NamespaceClient {
    * Creates a GeoServer REST NamespaceClient 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 namespaces.
    *
-   * @returns {Object|Boolean} An object describing the namespace or 'false'
+   * @throws Error if request fails
+   *
+   * @returns {Object} An object describing the namespace
    */
   async getAll () {
-    try {
-      const auth =
-        Buffer.from(this.user + ':' + this.password).toString('base64');
-      const response = await fetch(this.url + 'namespaces.json', {
-        credentials: 'include',
-        method: 'GET',
-        headers: {
-          Authorization: 'Basic ' + auth
-        }
-      });
-      const json = await response.json();
-      return json;
-    } catch (error) {
-      return false;
+    const response = await fetch(this.url + 'namespaces.json', {
+      credentials: 'include',
+      method: 'GET',
+      headers: {
+        Authorization: this.auth
+      }
+    });
+    if (!response.ok) {
+      const geoServerResponse = await getGeoServerResponseText(response);
+      throw new GeoServerResponseError(null, geoServerResponse);
     }
+    return response.json();
   }
 
   /**
@@ -48,66 +47,65 @@ export default class NamespaceClient {
    * @param {String} prefix Prefix of the new namespace
    * @param {String} uri Uri of the new namespace
    *
-   * @returns {String|Boolean} The name of the created namespace or 'false'
+   * @throws Error if request fails
+   *
+   * @returns {String} The name of the created namespace
    */
   async create (prefix, uri) {
-    try {
-      const body = {
-        namespace: {
-          prefix: prefix,
-          uri: uri
-        }
-      };
-
-      const auth =
-        Buffer.from(this.user + ':' + this.password).toString('base64');
+    const body = {
+      namespace: {
+        prefix: prefix,
+        uri: uri
+      }
+    };
 
-      const response = await fetch(this.url + 'namespaces', {
-        credentials: 'include',
-        method: 'POST',
-        headers: {
-          Authorization: 'Basic ' + auth,
-          'Content-Type': 'application/json'
-        },
-        body: JSON.stringify(body)
-      });
+    const response = await fetch(this.url + 'namespaces', {
+      credentials: 'include',
+      method: 'POST',
+      headers: {
+        Authorization: this.auth,
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(body)
+    });
 
-      if (response.status === 201) {
-        const responseText = await response.text();
-        return responseText;
-      } else {
-        return false;
-      }
-    } catch (error) {
-      return false;
+    if (!response.ok) {
+      const geoServerResponse = await getGeoServerResponseText(response);
+      throw new GeoServerResponseError(null, geoServerResponse);
     }
+
+    return response.text();
   }
 
   /**
    * Returns a namespace.
    *
    * @param {String} name Name of the namespace
-   * @returns {Object|Boolean} An object describing the namespace or 'false'
+   *
+   * @throws Error if request fails
+   *
+   * @returns {Object} An object describing the namespace or undefined if it cannot be found
    */
   async get (name) {
-    try {
-      const auth =
-        Buffer.from(this.user + ':' + this.password).toString('base64');
-      const response = await fetch(this.url + 'namespaces/' + name + '.json', {
-        credentials: 'include',
-        method: 'GET',
-        headers: {
-          Authorization: 'Basic ' + auth
-        }
-      });
-      if (response.status === 200) {
-        return await response.json();
+    const response = await fetch(this.url + 'namespaces/' + name + '.json', {
+      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 {
-        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();
   }
 
   /**
@@ -115,28 +113,31 @@ export default class NamespaceClient {
    *
    * @param {String} name Name of the namespace to delete
    *
-   * @returns {Boolean} If deletion was successful
+   * @throws Error if request fails
    */
   async delete (name) {
-    try {
-      const auth =
-        Buffer.from(this.user + ':' + this.password).toString('base64');
-      const response = await fetch(this.url + 'namespaces/' + name, {
-        credentials: 'include',
-        method: 'DELETE',
-        headers: {
-          Authorization: 'Basic ' + auth
-        }
-      });
+    const response = await fetch(this.url + 'namespaces/' + name, {
+      credentials: 'include',
+      method: 'DELETE',
+      headers: {
+        Authorization: this.auth
+      }
+    });
 
-      // TODO map other HTTP status
-      if (response.status === 200) {
-        return true;
-      } else {
-        return false;
+    if (!response.ok) {
+      const geoServerResponse = await getGeoServerResponseText(response);
+      switch (response.status) {
+        case 403:
+          throw new GeoServerResponseError(
+            'Namespace or related Workspace is not empty (and recurse not true)',
+            geoServerResponse);
+        case 404:
+          throw new GeoServerResponseError('Namespace doesn\'t exist', geoServerResponse);
+        case 405:
+          throw new GeoServerResponseError('Can\'t delete default namespace', geoServerResponse);
+        default:
+          throw new GeoServerResponseError('Response not recognized', geoServerResponse)
       }
-    } catch (error) {
-      return false;
     }
   }
 }

package/src/reset-reload.js

@@ -0,0 +1,70 @@
+import fetch from 'node-fetch';
+import { GeoServerResponseError, getGeoServerResponseText } from './util/geoserver.js';
+
+/**
+ * Client for GeoServer "Reset/Reload" to clear internal caches and reload
+ * configuration from disk endpoint.
+ *
+ * @module ResetReloadClient
+ */
+export default class ResetReloadClient {
+  /**
+   * Creates a GeoServer REST ResetReloadClient instance.
+   *
+   * @param {String} url The URL of the GeoServer REST API endpoint
+   * @param {String} auth The Basic Authentication string
+   */
+  constructor (url, auth) {
+    this.url = url;
+    this.auth = auth;
+  }
+
+  /**
+   * Resets all store, raster, and schema caches. This operation is used to
+   * force GeoServer to drop all caches and store connections and reconnect to
+   * each of them the next time they are needed by a request.
+   * This is useful in case the stores themselves cache some information about
+   * the data structures they manage that may have changed in the meantime.
+   *
+   * @throws Error if request fails
+   */
+  async reset () {
+    const url = this.url + 'reset';
+    const response = await fetch(url, {
+      credentials: 'include',
+      method: 'POST',
+      headers: {
+        Authorization: this.auth
+      }
+    });
+
+    if (!response.ok) {
+      const geoServerResponse = await getGeoServerResponseText(response);
+      throw new GeoServerResponseError(null, geoServerResponse);
+    }
+  }
+
+  /**
+   * Reloads the GeoServer catalog and configuration from disk. This operation
+   * is used in cases where an external tool has modified the on-disk
+   * configuration. This operation will also force GeoServer to drop any
+   * internal caches and reconnect to all data stores.
+   *
+   * @throws Error if request fails
+   */
+  async reload () {
+    const url = this.url + 'reload';
+    const response = await fetch(url, {
+      credentials: 'include',
+      method: 'POST',
+      headers: {
+        Authorization: this.auth
+      }
+    });
+
+    if (!response.ok) {
+      const geoServerResponse = await getGeoServerResponseText(response);
+      throw new GeoServerResponseError(null, geoServerResponse);
+    }
+  }
+}

package/src/security.js

@@ -1,4 +1,5 @@
 import fetch from 'node-fetch';
+import { getGeoServerResponseText, GeoServerResponseError } from './util/geoserver.js';
 
 /**
  * Client for GeoServer security.
@@ -10,39 +11,34 @@ export default class SecurityClient {
    * Creates a GeoServer REST SecurityClient 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;
   }
 
-  // TODO: I could not get it working, got Code '406'
   /**
    * Returns all users registered in GeoServer.
+   *
+   * @throws Error if request fails
+   *
+   * @returns {Object} An object with all users
    */
   async getAllUsers () {
-    try {
-      const auth = Buffer.from(this.user + ':' + this.password).toString('base64');
-      const response = await fetch(this.url + 'security/usergroup/users.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 + 'security/usergroup/users.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();
   }
 
   /**
@@ -51,7 +47,7 @@ export default class SecurityClient {
    * @param {String} username The name of the user to be created
    * @param {String} password The password of the user to be created
    *
-   * @returns {Boolean} If the user could be created
+   * @throws Error if request fails
    */
   async createUser (username, password) {
     const body = {
@@ -62,28 +58,24 @@ export default class SecurityClient {
       }
     };
 
-    try {
-      const auth = Buffer.from(this.user + ':' + this.password).toString('base64');
-      const response = await fetch(this.url + 'security/usergroup/users.json', {
-        credentials: 'include',
-        method: 'POST',
-        headers: {
-          Authorization: 'Basic ' + auth,
-          'Content-Type': 'application/json'
-        },
-        body: JSON.stringify(body)
-      });
+    const response = await fetch(this.url + 'security/usergroup/users.json', {
+      credentials: 'include',
+      method: 'POST',
+      headers: {
+        Authorization: this.auth,
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(body)
+    });
 
-      if (response.status === 201) {
-        return true;
-      } else if (response.status === 404) {
-        console.warn(`Received HTTP 404 - the user ${username} might already exist.`);
-      } else {
-        console.warn(await response.text());
-        return false;
+    if (!response.ok) {
+      const geoServerResponse = await getGeoServerResponseText(response);
+      switch (response.status) {
+        case 404:
+          throw new GeoServerResponseError(`User ${username} might already exists.`, geoServerResponse);
+        default:
+          throw new GeoServerResponseError(null, geoServerResponse);
       }
-    } catch (error) {
-      return false;
     }
   }
 
@@ -95,7 +87,7 @@ export default class SecurityClient {
    * @param {String} password The password of the user to be created
    * @param {Boolean} enabled Enable / disable the user
    *
-   * @returns {Boolean} If user could be updated
+   * @throws Error if request fails
    */
   async updateUser (username, password, enabled) {
     const body = {
@@ -105,26 +97,19 @@ export default class SecurityClient {
       }
     };
 
-    try {
-      const auth = Buffer.from(this.user + ':' + this.password).toString('base64');
-      const response = await fetch(this.url + 'security/usergroup/user/' + username, {
-        credentials: 'include',
-        method: 'POST',
-        headers: {
-          Authorization: 'Basic ' + auth,
-          'Content-Type': 'application/json'
-        },
-        body: JSON.stringify(body)
-      });
+    const response = await fetch(this.url + 'security/usergroup/user/' + username, {
+      credentials: 'include',
+      method: 'POST',
+      headers: {
+        Authorization: this.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;
+    if (!response.ok) {
+      const geoServerResponse = await getGeoServerResponseText(response);
+      throw new GeoServerResponseError(null, geoServerResponse);
     }
   }
 
@@ -134,28 +119,20 @@ export default class SecurityClient {
    * @param {String} username The name of the user to add the role to
    * @param {String} role The role to associate
    *
-   * @returns {Boolean} If the role could be associated
+   * @throws Error if request fails
    */
   async associateUserRole (username, role) {
-    try {
-      const auth = Buffer.from(this.user + ':' + this.password).toString('base64');
-      console.log(`${this.url}security/roles/role/${role}/user/${username}`);
-      const response = await fetch(`${this.url}security/roles/role/${role}/user/${username}`, {
-        credentials: 'include',
-        method: 'POST',
-        headers: {
-          Authorization: 'Basic ' + auth
-        }
-      });
-
-      if (response.status === 200) {
-        return true;
-      } else {
-        console.warn(await response.text());
-        return false;
+    const response = await fetch(`${this.url}security/roles/role/${role}/user/${username}`, {
+      credentials: 'include',
+      method: 'POST',
+      headers: {
+        Authorization: this.auth
       }
-    } catch (error) {
-      return false;
+    });
+
+    if (!response.ok) {
+      const geoServerResponse = await getGeoServerResponseText(response);
+      throw new GeoServerResponseError(null, geoServerResponse);
     }
   }
 }