geoserver-node-client 0.0.2 → 0.0.6

package/.github/workflows/ci-geoserver-node-client.yml

@@ -10,7 +10,7 @@ jobs:
   run-tests-maintenance:
     runs-on: ubuntu-latest
     env:
-      GEOSERVER_VERSION: 2.18.2
+      GEOSERVER_VERSION: 2.19.3
     steps:
       - uses: actions/checkout@v2
 
@@ -33,7 +33,7 @@ jobs:
   run-tests-stable:
     runs-on: ubuntu-latest
     env:
-      GEOSERVER_VERSION: 2.19.0
+      GEOSERVER_VERSION: 2.20.1
     steps:
       - uses: actions/checkout@v2
 

package/DOCS_HOME.md

@@ -8,8 +8,10 @@ Node.js / JavaScript Client for the [GeoServer REST API](https://docs.geoserver.
 
 Compatible with [GeoServer](https://geoserver.org)
 
-  - v2.17.x
-  - v2.18.x
+  - v2.20.x
+  - v2.19.x
+  - v2.18.x (no more maintained and officially deprecated)
+  - v2.17.x (no more maintained and officially deprecated)
 
 ### Who do I talk to? ###
 

package/LICENSE

@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2021, meggsimum (Dipl.-Ing. (FH) Christian Mayer)
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -1,5 +1,8 @@
 # GeoServer Node Client
 
+[![npm version](https://badge.fury.io/js/geoserver-node-client.svg)](https://www.npmjs.com/package/geoserver-node-client)
+![](https://github.com/meggsimum/geoserver-node-client/actions/workflows/ci-geoserver-node-client.yml/badge.svg)
+
 Node.js / JavaScript Client for the [GeoServer REST API](https://docs.geoserver.org/stable/en/user/rest/).
 
 **CAUTION: This is highly bleeding edge, heavily under development and therefore breaking changes can be made at every time!**
@@ -12,8 +15,9 @@ Detailed API-Docs can be found [here](https://meggsimum.github.io/geoserver-node
 
 Compatible with [GeoServer](https://geoserver.org)
 
+  - v2.20.x
   - v2.19.x
-  - v2.18.x
+  - v2.18.x (no more maintained and officially deprecated)
   - v2.17.x (no more maintained and officially deprecated)
 
 ### Setup
@@ -39,15 +43,41 @@ First start a GeoServer, e.g. by using this Docker container:
 docker run \
   -p 8080:8080 \
   -v /path/to/geoserver_mnt:/opt/geoserver_data \
-  meggsimum/geoserver:2.18.2
+  meggsimum/geoserver:2.20.1
 ```
 
 Then, in an other terminal, run:
 
 ```shell
-npm run test
+# specify the GeoServer version and run the test suite
+GEOSERVER_VERSION=2.20.1 npm run test
+```
+
+### Release
+
+The release to GitHub and npm is done via [release-it](https://github.com/release-it/release-it). This is the workflow for releasing:
+
+1. Make sure a `GITHUB_TOKEN` is available as environment variable. See [here](https://github.com/release-it/release-it/blob/master/docs/github-releases.md) for more information.
+
+```shell
+export GITHUB_TOKEN=ADD-YOUR-TOKEN-HERE
+```
+
+2. Make sure you are logged in to npm and ensure you have the rights to make a release.
+
+```shell
+npm login
+# then enter your credentials
+```
+
+3. Locally checkout the latest `master` branch that you would like to release, then run:
+
+```shell
+npm run release
 ```
 
+4. Follow the questions in the commandline.
+
 ### Who do I talk to? ###
 
 * meggsimum (Christian Mayer) - info __at## meggsimum ~~dot** de

package/demo/index.js

@@ -18,6 +18,23 @@ grc.getVersion().then(versionInfo => {
   console.log('GeoServer REST version info', prettyJson(versionInfo));
 });
 
+// NAMESPACES
+
+// const nsPrefix = 'example-namespace';
+// const nsUri = 'http://www.example.com'
+// grc.namespaces.create(nsPrefix, nsUri).then(retVal => {
+//   console.log('Created GeoServer NS', prettyJson(retVal));
+// });
+// grc.namespaces.getAll().then(gsNamespaces => {
+//   console.log('GeoServer All NS', prettyJson(gsNamespaces));
+// });
+// grc.namespaces.get(nsPrefix).then(gsNamespaces => {
+//   console.log('GeoServer NS', prettyJson(gsNamespaces));
+// });
+// grc.namespaces.delete(nsPrefix).then(gsNamespaces => {
+//   console.log('Deleted GeoServer NS', prettyJson(gsNamespaces));
+// });
+
 // WORKSPACES
 
 // grc.workspaces.getAll().then(gsWorkspaces => {
@@ -70,9 +87,9 @@ grc.getVersion().then(versionInfo => {
 // grc.datastores.createWmsStore(ws, 'testWmsDs', wmsUrl).then(retVal => {
 //   console.log('Created WMS data store', prettyJson(retVal));
 // });
-// const wfsCapsUrl = 'https://ows.terrestris.de/geoserver/osm/wfs?service=wfs&version=1.1.0&request=GetCapabilities';
+// const wfsCapsUrl = 'https://services.meggsimum.de/geoserver/ows?service=wfs&version=1.1.0&request=GetCapabilities';
 // const namespaceUrl = 'http://test';
-// grc.datastores.createWfsStore(ws, 'testWfsDs', wfsCapsUrl, namespaceUrl).then(retVal => {
+// grc.datastores.createWfsStore(ws, 'testWfsDs', wfsCapsUrl, namespaceUrl, false).then(retVal => {
 //   console.log('Created WFS data store', prettyJson(retVal));
 // });
 // grc.datastores.deleteDataStore(ws, 'testWfsDs', false).then(gsWmsStores => {

package/geoserver-rest-client.js

@@ -6,6 +6,7 @@ import DatastoreClient from './src/datastore.js';
 import ImageMosaicClient from './src/imagemosaic.js';
 import SecurityClient from './src/security.js';
 import SettingsClient from './src/settings.js';
+import NamespaceClient from './src/namespace.js';
 
 /**
  * Client for GeoServer REST API.
@@ -33,6 +34,8 @@ export default class GeoServerRestClient {
     this.styles = new StyleClient(this.url, this.user, this.password);
     /** @member {WorkspaceClient} workspaces GeoServer REST client instance for workspaces */
     this.workspaces = new WorkspaceClient(this.url, this.user, this.password);
+    /** @member {NamespaceClient} namespaces GeoServer REST client instance for namespaces */
+    this.namespaces = new NamespaceClient(this.url, this.user, this.password);
     /** @member {DatastoreClient} datastores GeoServer REST client instance for data stores */
     this.datastores = new DatastoreClient(this.url, this.user, this.password);
     /** @member {ImageMosaicClient} imagemosaics GeoServer REST client instance for image mosaics */
@@ -45,7 +48,7 @@ export default class GeoServerRestClient {
 
   /**
    * Get the GeoServer version.
-   * 
+   *
    * @returns {String|Boolean} The version of GeoServer or 'false'
    */
   async getVersion () {
@@ -67,7 +70,7 @@ export default class GeoServerRestClient {
 
   /**
    * Checks if the configured GeoServer REST connection exists.
-   * 
+   *
    * @returns {Boolean} If the connection exists
    */
   async exists () {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "geoserver-node-client",
-  "version": "0.0.2",
+  "version": "0.0.6",
   "description": "Node.js client for GeoServer REST API",
   "type": "module",
   "main": "geoserver-rest-client.js",
@@ -20,18 +20,18 @@
   "author": "C. Mayer, meggsimum (info_at*meggsimum?dot?de)",
   "license": "BSD-2-Clause",
   "dependencies": {
-    "node-fetch": "^2.6.1"
+    "node-fetch": "^2.6.5"
   },
   "devDependencies": {
-    "chai": "^4.3.0",
-    "eslint": "^7.21.0",
+    "chai": "^4.3.4",
+    "eslint": "^7.32.0",
     "eslint-config-standard": "^14.1.1",
-    "eslint-plugin-import": "^2.22.1",
+    "eslint-plugin-import": "^2.25.2",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-promise": "^4.3.1",
     "eslint-plugin-standard": "^4.1.0",
-    "jsdoc": "^3.6.6",
-    "mocha": "^8.3.0",
-    "release-it": "^14.10.0"
+    "jsdoc": "^3.6.7",
+    "mocha": "^9.1.3",
+    "release-it": "^14.11.6"
   }
 }

package/src/datastore.js

@@ -228,6 +228,7 @@ s  */
    * Creates a PostGIS based data store.
    *
    * @param {String} workspace The WS to create the data store in
+   * @param {String} namespaceUri The namespace URI of the workspace
    * @param {String} dataStore The data store name to be created
    * @param {String} pgHost The PostGIS DB host
    * @param {String} pgPort The PostGIS DB port
@@ -239,12 +240,15 @@ s  */
    *
    * @returns {Boolean} If the store could be created
    */
-  async createPostgisStore (workspace, dataStore, pgHost, pgPort, pgUser, pgPassword, pgSchema, pgDb, exposePk) {
+  async createPostgisStore (workspace, namespaceUri, dataStore, pgHost, pgPort, pgUser, pgPassword, pgSchema, pgDb, exposePk) {
     const body = {
       dataStore: {
         name: dataStore,
         type: 'PostGIS',
         enabled: true,
+        workspace: {
+          name: workspace
+        },
         connectionParameters: {
           entry: [
             {
@@ -273,7 +277,7 @@ s  */
             },
             {
               '@key': 'namespace',
-              $: workspace
+              $: namespaceUri
             },
             {
               '@key': 'user',
@@ -397,10 +401,11 @@ s  */
    * @param {String} dataStore The data store name
    * @param {String} wfsCapabilitiesUrl WFS capabilities URL
    * @param {String} namespaceUrl URL of the GeoServer namespace
+   * @param {Boolean} [useHttpConnectionPooling=true] use HTTP connection pooling for WFS connection
    *
    * @returns {Boolean} If store could be created
    */
-  async createWfsStore (workspace, dataStore, wfsCapabilitiesUrl, namespaceUrl) {
+  async createWfsStore (workspace, dataStore, wfsCapabilitiesUrl, namespaceUrl, useHttpConnectionPooling) {
     const body = {
       dataStore: {
         name: dataStore,
@@ -414,6 +419,10 @@ s  */
             {
               '@key': 'namespace',
               $: namespaceUrl
+            },
+            {
+              '@key': 'WFSDataStoreFactory:USE_HTTP_CONNECTION_POOLING',
+              $: useHttpConnectionPooling !== false ? 'true' : 'false'
             }
           ]
         }

package/src/layer.js

@@ -369,10 +369,11 @@ export default class LayerClient {
    * @param {String} defaultValue The default time value, e.g. 'MINIMUM' or 'MAXIMUM' or 'NEAREST' or 'FIXED'
    * @param {Boolean} [nearestMatchEnabled] Enable nearest match
    * @param {Boolean} [rawNearestMatchEnabled] Enable raw nearest match
+   * @param {String} [acceptableInterval] Acceptable interval for nearest match, e.g.'PT30M'
    *
    * @returns If time dimension could be enabled
    */
-  async enableTimeCoverage (workspace, dataStore, name, presentation, resolution, defaultValue, nearestMatchEnabled, rawNearestMatchEnabled) {
+  async enableTimeCoverage (workspace, dataStore, name, presentation, resolution, defaultValue, nearestMatchEnabled, rawNearestMatchEnabled, acceptableInterval) {
     try {
       const body = {
         coverage: {
@@ -389,7 +390,8 @@ export default class LayerClient {
                     strategy: defaultValue
                   },
                   nearestMatchEnabled: nearestMatchEnabled,
-                  rawNearestMatchEnabled: rawNearestMatchEnabled
+                  rawNearestMatchEnabled: rawNearestMatchEnabled,
+                  acceptableInterval: acceptableInterval
                 }
               }
             ]

package/src/namespace.js

@@ -0,0 +1,142 @@
+import fetch from 'node-fetch';
+
+/**
+ * Client for GeoServer namespace
+ *
+ * @module NamespaceClient
+ */
+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
+   */
+  constructor (url, user, password) {
+    this.url = url.endsWith('/') ? url : url + '/';
+    this.user = user;
+    this.password = password;
+  }
+
+  /**
+   * Returns all namespaces.
+   *
+   * @returns {Object|Boolean} An object describing the namespace or 'false'
+   */
+  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;
+    }
+  }
+
+  /**
+   * Creates a new namespace.
+   *
+   * @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'
+   */
+  async create (prefix, uri) {
+    try {
+      const body = {
+        namespace: {
+          prefix: prefix,
+          uri: uri
+        }
+      };
+
+      const auth =
+        Buffer.from(this.user + ':' + this.password).toString('base64');
+
+      const response = await fetch(this.url + 'namespaces', {
+        credentials: 'include',
+        method: 'POST',
+        headers: {
+          Authorization: 'Basic ' + 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;
+    }
+  }
+
+  /**
+   * Returns a namespace.
+   *
+   * @param {String} name Name of the namespace
+   * @returns {Object|Boolean} An object describing the namespace or 'false'
+   */
+  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();
+      } else {
+        return false;
+      }
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Deletes a namespace.
+   *
+   * @param {String} name Name of the namespace to delete
+   *
+   * @returns {Boolean} If deletion was successful
+   */
+  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
+        }
+      });
+
+      // TODO map other HTTP status
+      if (response.status === 200) {
+        return true;
+      } else {
+        return false;
+      }
+    } catch (error) {
+      return false;
+    }
+  }
+}

package/test/test.js

@@ -9,6 +9,10 @@ const pw = 'geoserver';
 const grc = new GeoServerRestClient(url, user, pw);
 
 const workSpace = 'my-workspace';
+
+const nameSpace = 'my-namespace';
+const nameSpaceUri = 'http://www.example.com';
+
 const geoServerVersion = process.env.GEOSERVER_VERSION;
 
 describe('Basic GeoServer', () => {
@@ -126,6 +130,40 @@ describe('Workspace', () => {
   });
 });
 
+describe('Namespace', () => {
+  it('has no namespaces', async () => {
+    const gsNamespaces = await grc.namespaces.getAll();
+    expect(gsNamespaces.namespaces).to.equal('');
+  });
+
+  it('creates one namespace', async () => {
+    const result = await grc.namespaces.create(nameSpace, nameSpaceUri);
+    expect(result).to.equal(nameSpace);
+  });
+
+  it('has one namespace', async () => {
+    const gsNameSpaces = await grc.namespaces.getAll();
+    expect(gsNameSpaces.namespaces.namespace.length).to.equal(1);
+    expect(gsNameSpaces.namespaces.namespace[0].name).to.equal(nameSpace);
+  });
+
+  it('query dedicated namespace', async () => {
+    const gsNameSpace = await grc.namespaces.get(nameSpace);
+    expect(gsNameSpace.namespace.prefix).to.equal(nameSpace);
+    expect(gsNameSpace.namespace.uri).to.equal(nameSpaceUri);
+  });
+
+  it('delete namespace', async () => {
+    const result = await grc.namespaces.delete(nameSpace);
+    expect(result).to.be.true;
+  });
+
+  it('has no namespace', async () => {
+    const gsNameSpaces = await grc.namespaces.getAll();
+    expect(gsNameSpaces.namespaces).to.equal('');
+  });
+});
+
 describe('Datastore', () => {
   let createdWorkSpace;
 

package/demo/dev.js

@@ -1,275 +0,0 @@
-import GeoServerRestClient from '../geoserver-rest-client.js';
-import fs from 'fs';
-import { execSync } from 'child_process'
-
-const geoserverUrl = 'http://localhost:8080/geoserver/rest/';
-const geoserverDefaultUser = 'mgsm-admin';
-const geoserverDefaultPw = 'VB?w10&0A2s8PU?BPM&Nn!8kl';
-const role = 'ADMIN';
-
-// TODO: read from secrets
-const newGeoserverUser = 'mgsm-admin';
-const newGeoserverPw = 'VB?w10&0A2s8PU?BPM&Nn!8kl';
-
-const workspaceWorld = 'mgsm-world';
-const workspaceGermany = 'mgsm-ger';
-
-const gsDataDir = '/opt/geoserver_data/';
-const countriesGpkgUrl = 'https://github.com/JakobMiksch/geodata/raw/main/vector-data.gpkg?raw=true';
-const worldRasterUrl = 'https://github.com/JakobMiksch/geodata/raw/main/world.tiff';
-const neGpkgPath = gsDataDir + 'natural_earth_vector.gpkg';
-const neWorldRasterPath = gsDataDir + 'world.tif';
-const worldRasterDs = 'world-raster';
-const worldRasterLayer = 'ne_world';
-const worldRasterTitle = 'World Image';
-
-const postalCodesUrl = 'https://github.com/JakobMiksch/geodata/raw/main/postal_codes_germany.gpkg';
-const postalCodesPath = gsDataDir + 'postal_codes.gpkg';
-
-/**
- * Main function
- */
-async function initGeoserver () {
-  console.log('accessing geoserver');
-  const workspaceGermany = 'mgsm-ger';
-  const gpkgStore = 'postal-code-store';
-  const nativeLayerName = undefined;
-  const layerName = 'postal_codes_germany';
-  const layerTitle = 'Postal Codes Germany';
-
-  const layerCreated = await grc.layers.publishFeatureType(
-    workspaceGermany, gpkgStore, nativeLayerName, layerName, layerTitle,
-    'EPSG:4326', true, 'asdfasdfasdfasdf asdfasdfsadf asdfasdf afas asdf asdfas asdf asdfas asdf asdfas asfd asdfas as dfas dfasdf asdf asdfas asdfa sdfawesdf'
-  );
-
-  console.log(layerCreated);
-
-  // let result;
-  // result = await grc.layers.get('mgsm-ger:postal_codes_germany');
-  // console.log(result);
-
-  // result = await grc.layers.modifyAttribution('mgsm-ger:postal_codes_germany', 'Apfelbaum', 'www.zeit.de');
-  // console.log(result);
-
-  // result = await grc.layers.get('mgsm-ger:postal_codes_germany');
-  // console.log(result);
-
-  // await addContactInformation();
-
-  // await adaptSecurity();
-
-  // await createWorkspaces();
-
-  // await publishGlobalVectorData();
-
-  // await publishWorldRaster();
-
-  // await publishPostalCodes();
-}
-
-/**
- * Adapts security settings for GeoServer
- */
-async function adaptSecurity () {
-  const user = newGeoserverUser;
-  const userPw = newGeoserverPw;
-
-  if (!user || !userPw || user === '' || userPw === '') {
-    console.error('No valid user or user password given - EXIT.');
-  }
-
-  const userCreated = await grc.security.createUser(user, userPw);
-  if (userCreated) {
-    console.info('Successfully created user', user);
-  }
-
-  const roleAssigend = await grc.security.associateUserRole(user, role);
-  if (roleAssigend) {
-    console.info(`Successfully added role ${role} to user ${user}`);
-  }
-
-  // disable user
-  const adminDisabled = await grc.security.updateUser(geoserverDefaultUser, geoserverDefaultPw, false);
-  if (adminDisabled) {
-    console.info('Successfully disabled default "admin" user');
-  }
-}
-
-/**
- * Adds basic contact information
- */
-async function addContactInformation () {
-  const address = 'Schillerstraße 2a';
-  const city = 'Mutterstadt';
-  const country = 'Deutschland';
-  const state = undefined;
-  const postalCode = '67112';
-  const email = 'info@meggsimum.de';
-  const organization = 'meggsimum – Büro für Geoinformatik';
-  const contactPerson = 'Christian Mayer';
-  const phoneNumber = undefined;
-
-  const result = await grc.settings.updateContactInformation(address, city, country, postalCode, state, email, organization, contactPerson, phoneNumber);
-  if (result) {
-    console.log('Changed contact information.');
-  }
-}
-
-/**
- * Creates the basic workspaces
- */
-async function createWorkspaces () {
-  const wsWorldCreated = await grc.workspaces.create(workspaceWorld);
-  console.log('Created Workspace World', wsWorldCreated);
-
-  const wsGermanyCreated = await grc.workspaces.create(workspaceGermany);
-  console.log('Created Workspace Germany', wsGermanyCreated);
-}
-
-/**
- * Publish postal codes from Germany
- */
-async function publishPostalCodes () {
-  const gpkgStore = 'postal-code-store';
-  const nativeLayerName = undefined;
-  const layerName = 'postal_codes_germany';
-  const layerTitle = 'Postal Codes Germany';
-
-  const wsExists =
-    await grc.datastores.getDataStore(workspaceGermany, gpkgStore);
-  const lyrExists =
-    await grc.layers.get(`${workspaceGermany}:${layerName}`);
-
-  if (wsExists && lyrExists) {
-    console.info('Datastore and layer for postal codes already exist - SKIP!');
-    return;
-  }
-
-  // TODO replace by native node call
-  execSync(`wget -N -O ${postalCodesPath} ${postalCodesUrl}`);
-
-  const postalStoreCreated = await grc.datastores.createGpkgStore(
-    workspaceGermany, gpkgStore, postalCodesPath
-  );
-
-  console.log('Successfully created postal code GPKG store', postalStoreCreated);
-
-  const layerCreated = await grc.layers.publishFeatureType(
-    workspaceGermany, gpkgStore, nativeLayerName, layerName, layerTitle,
-    'EPSG:4326', true
-  );
-
-  if (layerCreated) {
-    console.log(`Created vector layer for postal codes "${layerName}"`);
-  }
-}
-
-/**
- * Publishes the world vector data (currently countries, rivers, places)
- */
-async function publishGlobalVectorData () {
-  const gpkgStore = 'natural-earth-gpkg-store';
-  const countriesLyr = 'ne_10m_admin_0_countries';
-  const riversLyr = 'ne_10m_rivers_lake_centerlines';
-  const placesLyr = 'ne_10m_populated_places';
-
-  const wsExists =
-    await grc.datastores.getDataStore(workspaceWorld, gpkgStore);
-  const lyr1Exists =
-    await grc.layers.get(`${workspaceWorld}:${countriesLyr}`);
-  const lyr2Exists =
-    await grc.layers.get(`${workspaceWorld}:${riversLyr}`);
-  const lyr3Exists =
-    await grc.layers.get(`${workspaceWorld}:${placesLyr}`);
-
-  if (wsExists && lyr1Exists && lyr2Exists && lyr3Exists) {
-    console.info('Datastore and layers for global vector data already exist - SKIP!');
-    return;
-  }
-
-  // TODO replace by native node call
-  execSync(`wget -N -O ${neGpkgPath} ${countriesGpkgUrl}`);
-
-  // NOTE: here the relative path within the GeoServer is required
-  const neStoreCreated = await grc.datastores.createGpkgStore(
-    workspaceWorld, gpkgStore, neGpkgPath
-  );
-
-  console.log('Successfully created NE GPKG store', neStoreCreated);
-
-  // publish vector layers
-  publishVectorLayerWithStyle(gpkgStore, countriesLyr, 'World Countries', 'countries');
-  publishVectorLayerWithStyle(gpkgStore, riversLyr, 'World Rivers', 'rivers');
-  publishVectorLayerWithStyle(gpkgStore, placesLyr, 'World Places', 'places');
-}
-
-/**
- * Util for publishing a layer with a style
- */
-async function publishVectorLayerWithStyle (store, layerName, layerTitle, styleName) {
-  const nativeLayerName = undefined;
-
-  const layerCreated = await grc.layers.publishFeatureType(
-    workspaceWorld, store, nativeLayerName, layerName, layerTitle,
-    'EPSG:4326', true
-  );
-
-  if (layerCreated) {
-    console.log(`Created vector layer "${layerName}"`);
-  }
-
-  try {
-    const sldFilePath = styleName + '.sld';
-    const sldBody = fs.readFileSync(sldFilePath, 'utf8');
-
-    // publish style
-    const stylePublished = await grc.styles.publish(workspaceWorld, styleName, sldBody);
-
-    console.log('Published style: ', stylePublished);
-
-    const qualifiedName = `${workspaceWorld}:${layerName}`;
-    const styleAssigend = await grc.styles.assignStyleToLayer(qualifiedName, styleName,
-      workspaceWorld, true
-    );
-
-    console.log(`Style "${styleName}" assigned to layer "${qualifiedName}"`, styleAssigend);
-  } catch (e) {
-    console.error('Error:', e.stack);
-  }
-}
-
-/**
- * Publishes the NE GeoTiff based World Raster
- */
-async function publishWorldRaster () {
-  const wsExists =
-    await grc.datastores.getCoverageStore(workspaceWorld, worldRasterDs);
-  const lyrExists = await grc.layers.get(`${workspaceWorld}:${worldRasterLayer}`);
-
-  if (wsExists && lyrExists) {
-    console.info('Datastore and layer for world raster data already exist - SKIP!');
-    return;
-  }
-
-  // TODO replace by native node call
-  execSync(`wget -N -O ${neWorldRasterPath} ${worldRasterUrl}`);
-
-  console.log('Downloaded GeoTIFF file');
-
-  const geotiffCreated = await grc.datastores.createGeotiffFromFile(
-    workspaceWorld, worldRasterDs, worldRasterLayer,
-    worldRasterTitle, neWorldRasterPath
-  );
-
-  console.log('Created GeoTIFF world raster layer', geotiffCreated);
-}
-
-// check if we can connect to GeoServer REST API
-const grc = new GeoServerRestClient(geoserverUrl, geoserverDefaultUser, geoserverDefaultPw);
-grc.exists().then(gsExists => {
-  if (gsExists === true) {
-    initGeoserver();
-  } else {
-    console.error('Could not connect to GeoServer REST API - ABORT!');
-  }
-});