geoserver-node-client 1.0.0 → 1.2.1

package/dist/src/reset-reload.js

@@ -0,0 +1,160 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _nodeFetch = _interopRequireDefault(require("node-fetch"));
+
+var _geoserver = require("./util/geoserver.js");
+
+/**
+ * Client for GeoServer "Reset/Reload" to clear internal caches and reload
+ * configuration from disk endpoint.
+ *
+ * @module ResetReloadClient
+ */
+var ResetReloadClient = /*#__PURE__*/function () {
+  /**
+   * Creates a GeoServer REST ResetReloadClient instance.
+   *
+   * @param {String} url The URL of the GeoServer REST API endpoint
+   * @param {String} auth The Basic Authentication string
+   */
+  function ResetReloadClient(url, auth) {
+    (0, _classCallCheck2["default"])(this, ResetReloadClient);
+    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
+   */
+
+
+  (0, _createClass2["default"])(ResetReloadClient, [{
+    key: "reset",
+    value: function () {
+      var _reset = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+        var url, response, geoServerResponse;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                url = this.url + 'reset';
+                _context.next = 3;
+                return (0, _nodeFetch["default"])(url, {
+                  credentials: 'include',
+                  method: 'POST',
+                  headers: {
+                    Authorization: this.auth
+                  }
+                });
+
+              case 3:
+                response = _context.sent;
+
+                if (response.ok) {
+                  _context.next = 9;
+                  break;
+                }
+
+                _context.next = 7;
+                return (0, _geoserver.getGeoServerResponseText)(response);
+
+              case 7:
+                geoServerResponse = _context.sent;
+                throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
+
+              case 9:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function reset() {
+        return _reset.apply(this, arguments);
+      }
+
+      return reset;
+    }()
+    /**
+     * 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
+     */
+
+  }, {
+    key: "reload",
+    value: function () {
+      var _reload = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+        var url, response, geoServerResponse;
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                url = this.url + 'reload';
+                _context2.next = 3;
+                return (0, _nodeFetch["default"])(url, {
+                  credentials: 'include',
+                  method: 'POST',
+                  headers: {
+                    Authorization: this.auth
+                  }
+                });
+
+              case 3:
+                response = _context2.sent;
+
+                if (response.ok) {
+                  _context2.next = 9;
+                  break;
+                }
+
+                _context2.next = 7;
+                return (0, _geoserver.getGeoServerResponseText)(response);
+
+              case 7:
+                geoServerResponse = _context2.sent;
+                throw new _geoserver.GeoServerResponseError(null, geoServerResponse);
+
+              case 9:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+
+      function reload() {
+        return _reload.apply(this, arguments);
+      }
+
+      return reload;
+    }()
+  }]);
+  return ResetReloadClient;
+}();
+
+exports["default"] = ResetReloadClient;

package/geoserver-rest-client.js

@@ -7,6 +7,7 @@ import SecurityClient from './src/security.js';
 import SettingsClient from './src/settings.js';
 import NamespaceClient from './src/namespace.js';
 import AboutClient from './src/about.js';
+import ResetReloadClient from './src/reset-reload.js';
 
 export { GeoServerResponseError } from './src/util/geoserver.js'
 
@@ -47,5 +48,7 @@ export class GeoServerRestClient {
     this.settings = new SettingsClient(this.url, this.auth);
     /** @member {AboutClient} about GeoServer REST client instance for about endpoint */
     this.about = new AboutClient(this.url, this.auth);
+    /** @member {ResetReloadClient} about GeoServer REST client instance for reset/reload endpoints */
+    this.resetReload = new ResetReloadClient(this.url, this.auth);
   }
 }

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "geoserver-node-client",
-  "version": "1.0.0",
+  "version": "1.2.1",
   "description": "Node.js client for GeoServer REST API",
   "type": "module",
   "main": "geoserver-rest-client.js",
   "scripts": {
     "demo": "node demo/index.js",
-    "docs": "./node_modules/.bin/jsdoc geoserver-rest-client.js src/*.js DOCS_HOME.md",
+    "docs": "./node_modules/.bin/jsdoc geoserver-rest-client.js src/*.js DOCS_HOME.md && cp img/*.png out/",
     "lint": "eslint src/**/*.js test/**/*.js scripts/**/*.js geoserver-rest-client.js",
     "lint-fix": "eslint --fix  src/**/*.js test/**/*.js scripts/**/*.js geoserver-rest-client.js",
     "pretest": "npm run lint",
@@ -34,6 +34,7 @@
   "author": "C. Mayer, meggsimum (info_at*meggsimum?dot?de)",
   "license": "BSD-2-Clause",
   "dependencies": {
+    "@babel/runtime": "^7.18.3",
     "node-fetch": "^2.6.5"
   },
   "devDependencies": {

package/src/datastore.js

@@ -378,6 +378,41 @@ export default class DatastoreClient {
     }
   }
 
+  /**
+   * Creates a WMTS based data store.
+   *
+   * @param {String} workspace The WS to create the data store in
+   * @param {String} dataStore The data store name
+   * @param {String} wmtsCapabilitiesUrl Base WMTS capabilities URL
+   *
+   * @throws Error if request fails
+   */
+  async createWmtsStore (workspace, dataStore, wmtsCapabilitiesUrl) {
+    const body = {
+      wmtsStore: {
+        name: dataStore,
+        type: 'WMTS',
+        capabilitiesURL: wmtsCapabilitiesUrl
+      }
+    };
+
+    const url = this.url + 'workspaces/' + workspace + '/wmtsstores';
+    const response = await fetch(url, {
+      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);
+    }
+  }
+
   /**
    * Creates a WFS based data store.
    *

package/src/imagemosaic.js

@@ -23,7 +23,7 @@ export default class ImageMosaicClient {
    *
    * @param {String} workspace Workspace of image mosaic
    * @param {String} coverageStore CoverageStore of image mosaic
-   * @param {*} coverage Name of image mosaic
+   * @param {String} coverage Name of image mosaic
    *
    * @throws Error if request fails
    *

package/src/layer.js

@@ -133,6 +133,103 @@ export default class LayerClient {
     return response.json();
   }
 
+  /**
+   * Get all layers of a workspace.
+   *
+   * @param {String} workspace The workspace
+   *
+   * @throws Error if request fails
+   *
+   * @return {Object} An object with the information about the layers
+   */
+  async getLayers (workspace) {
+    const response = await fetch(this.url + 'workspaces/' + workspace + '/layers.json', {
+      credentials: 'include',
+      method: 'GET',
+      headers: {
+        Authorization: this.auth,
+      }
+    });
+
+    if (!response.ok) {
+      const geoServerResponse = await getGeoServerResponseText(response);
+      throw new GeoServerResponseError(null, geoServerResponse);
+    }
+
+    return await response.json();
+  }
+
+  /**
+   * Returns information about a cascaded WMS layer.
+   *
+   * @param {String} workspace The workspace
+   * @param {String} datastore The datastore
+   * @param {String} layerName The WMS layer name
+   *
+   * @throws Error if request fails
+   *
+   * @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,
+      }
+    });
+
+    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 await response.json();
+  }
+
+  // TODO: automated test needed
+  /**
+   * Returns information about a cascaded WMTS layer.
+   *
+   * @param {String} workspace The workspace
+   * @param {String} datastore The datastore
+   * @param {String} layerName The WMTS layer name
+   *
+   * @throws Error if request fails
+   *
+   * @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,
+      }
+    });
+
+    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 await response.json();
+  }
+
   /**
    * Publishes a FeatureType in the default data store of the workspace.
    *

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);
+    }
+  }
+}