geoserver-node-client 0.0.5 → 1.0.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/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);
     }
   }
 }

package/src/settings.js

@@ -1,4 +1,5 @@
 import fetch from 'node-fetch';
+import { getGeoServerResponseText, GeoServerResponseError } from './util/geoserver.js';
 
 /**
  * Client for GeoServer settings.
@@ -10,60 +11,54 @@ export default class SettingsClient {
    * Creates a GeoServer REST SettingsClient 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;
   }
 
   /**
    * Get the complete GeoServer settings object.
    *
-   * @returns {Object|Boolean} Settings object or 'false'
+   * @throws Error if request fails
+   *
+   * @returns {Object} Settings object
    */
   async getSettings () {
-    try {
-      const auth =
-        Buffer.from(this.user + ':' + this.password).toString('base64');
-      const response = await fetch(this.url + 'settings.json', {
-        credentials: 'include',
-        method: 'GET',
-        headers: {
-          Authorization: 'Basic ' + auth
-        }
-      });
-      return await response.json();
-    } catch (error) {
-      return false;
+    const response = await fetch(this.url + 'settings.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();
   }
 
   /**
    * Update the global GeoServer settings.
    *
-   * @param {GeoServer} settings
-   * @returns {Boolean} Flag indicating if request was successful
+   * @param {Object} settings The adapted GeoServer settings object
    */
   async updateSettings (settings) {
-    try {
-      const auth =
-        Buffer.from(this.user + ':' + this.password).toString('base64');
-      const response = await fetch(this.url + 'settings', {
-        credentials: 'include',
-        method: 'PUT',
-        headers: {
-          Authorization: 'Basic ' + auth,
-          'Content-Type': 'application/json'
-        },
-        body: JSON.stringify(settings)
-      });
+    const response = await fetch(this.url + 'settings', {
+      credentials: 'include',
+      method: 'PUT',
+      headers: {
+        Authorization: this.auth,
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(settings)
+    });
 
-      return response.status === 200;
-    } catch (error) {
-      return false;
+    if (!response.ok) {
+      const geoServerResponse = await getGeoServerResponseText(response);
+      throw new GeoServerResponseError(null, geoServerResponse);
     }
   }
 
@@ -71,42 +66,41 @@ export default class SettingsClient {
    * Update the global proxyBaseUrl setting.
    *
    * @param {String} proxyBaseUrl The proxy base URL
-   * @returns {Boolean} Flag indicating if request was successful
    */
   async updateProxyBaseUrl (proxyBaseUrl) {
     const settingsJson = await this.getSettings();
 
+    // check if settings are correctly formatted
     if (!settingsJson.global && !settingsJson.global.settings) {
-      // settings seem to be wrongly formated
       return false;
     }
 
     // add proxyBaseUrl to settings
     settingsJson.global.settings.proxyBaseUrl = proxyBaseUrl;
 
-    return await this.updateSettings(settingsJson);
+    await this.updateSettings(settingsJson);
   }
 
   /**
    * Get the contact information of the GeoServer.
    *
-   * @returns {Object|Boolean} An object with contact information or 'false'
+   * @throws Error if request fails
+   *
+   * @returns {Object} An object with contact information
    */
   async getContactInformation () {
-    try {
-      const auth =
-        Buffer.from(this.user + ':' + this.password).toString('base64');
-      const response = await fetch(this.url + 'settings/contact', {
-        credentials: 'include',
-        method: 'GET',
-        headers: {
-          Authorization: 'Basic ' + auth
-        }
-      });
-      return await response.json();
-    } catch (error) {
-      return false;
+    const response = await fetch(this.url + 'settings/contact', {
+      credentials: 'include',
+      method: 'GET',
+      headers: {
+        Authorization: this.auth
+      }
+    });
+    if (!response.ok) {
+      const geoServerResponse = await getGeoServerResponseText(response);
+      throw new GeoServerResponseError(null, geoServerResponse);
     }
+    return response.json();
   }
 
   /**
@@ -124,47 +118,38 @@ export default class SettingsClient {
    * @param {String} [contactPerson] The contact person
    * @param {String} [phoneNumber] The contact's phone number
    *
-   * @returns {Boolean} If contact information could be updated.
+   * @throws Error if request fails
    */
   async updateContactInformation (address, city, country, postalCode, state, email, organization, contactPerson, phoneNumber) {
-    try {
-      const contact = {
-        address: address,
-        addressCity: city,
-        addressCountry: country,
-        addressPostalCode: postalCode,
-        addressState: state,
-        contactEmail: email,
-        contactOrganization: organization,
-        contactPerson: contactPerson,
-        contactVoice: phoneNumber
-      };
-
-      const body = {
-        contact: contact
-      };
+    const contact = {
+      address: address,
+      addressCity: city,
+      addressCountry: country,
+      addressPostalCode: postalCode,
+      addressState: state,
+      contactEmail: email,
+      contactOrganization: organization,
+      contactPerson: contactPerson,
+      contactVoice: phoneNumber
+    };
 
-      const auth = Buffer.from(this.user + ':' + this.password).toString('base64');
-      const url = this.url + 'settings/contact';
-      const response = await fetch(url, {
-        credentials: 'include',
-        method: 'PUT',
-        headers: {
-          Authorization: 'Basic ' + auth,
-          'Content-Type': 'application/json'
-        },
-        body: JSON.stringify(body)
-      });
+    const body = {
+      contact: contact
+    };
 
-      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 + 'settings/contact';
+    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);
     }
   }
 }