add base storage

config.js

 const config = {
-  port: 9000
+  port: 9000,
+  storage: {
+    type: "JSON",
+    path: "./assets/assets.json"
+  }
 }
 
 module.exports = config;
\ No newline at end of file

routes/assets.js

 const express = require("express");
 const path = require("path");
-const assets = require("../src/assets");
+const BaseStorage = require('../src/baseStorage');
+
+const storage = new BaseStorage().getInstance();
 
 let router = express.Router();
 
@@ -8,7 +10,7 @@ router.route("/*")
   .get((req, res, next) => {
 
     let fullUrl = `${req.protocol}://${req.get("host")}${req.originalUrl}`;
-    assets.isPublic(fullUrl).then(result => {
+    storage.isPublic(fullUrl).then(result => {
       if (result) {
         next();
       } else {

src/assets.js

-const fs = require("fs");
-const boxIntersect = require("box-intersect");
-const path = require('path');
-
-const getLayers = (layers, boundingbox) => {
-  if (boundingbox === undefined) {
-
-    return new Promise((resolve, reject) => {
-      fs.readFile("./assets/assets.json", (err, data) => {
-        if (err) {
-          reject();
-        }
-        let assets = JSON.parse(data);
-        let requestedLayers = layers.split(",");
-        assets = assets.filter(asset => requestedLayers.includes(asset.id));
-        assets = assets.filter(asset => asset.scope == "public");
-        resolve(assets);
-      });
-    });
-
-  } else {
-
-    return getIntersectingLayers(layers, boundingbox);
-
-  }
-
-}
-
-const getIntersectingLayers = (layers,bb) => {
-
-  return new Promise((resolve, reject) => {
-    fs.readFile("./assets/assets.json", (err, data) => {
-      if (err) {
-        reject();
-      }
-      let assets = JSON.parse(data);
-      let requestedBB = bb.split(",").map(token => parseFloat(token));
-      let requestedLayers = layers.split(",");
-
-      assets = assets.filter(asset => requestedLayers.includes(asset.id));
-      assets = assets.filter(asset => asset.scope == "public");
-
-      assets = assets.filter(asset => {
-
-        let overlaps = boxIntersect([
-          [...asset.boundingbox],
-          [...requestedBB]
-        ]);
-
-        if (overlaps.length > 0) {
-          return true;
-        }
-        return false;
-      });
-
-      resolve(assets);
-
-    });
-  });
-
-}
-
-const allLayersExist = (layers) => {
-
-  if (!layers) return Promise.reject();
-
-  return new Promise((resolve, reject) => {
-    fs.readFile("./assets/assets.json", (err, data) => {
-      if (err) {
-        reject();
-      }
-      let assets = JSON.parse(data);
-      layers = layers.split(",");
-      layers.forEach(layer => {
-        if (assets.findIndex(asset => asset.id == layer) == -1) {
-          reject();
-        }
-      });
-      resolve();
-    });
-  });
-
-}
-
-const getPublicLayers = () => {
-
-  return new Promise((resolve, reject) => {
-    fs.readFile("./assets/assets.json", (err, data) => {
-      let assets = JSON.parse(data);
-      assets = assets.filter(asset => asset.scope == "public");
-      resolve(assets);
-    });
-  });
-
-}
-
-const isPublic = (url) => {
-
-  return new Promise((resolve, reject) => {
-    fs.readFile("./assets/assets.json", (err, data) => {
-      let assets = JSON.parse(data);
-      assets = assets.filter(asset => {
-        let parentDir = path.dirname(asset.url);
-        return !path.relative(parentDir, url).startsWith("..");
-      });
-      if (assets.length == 0) {
-        resolve(false);
-        return;
-      }
-      if (!assets[0].scope == "public") {
-        resolve(false);
-        return;
-      }
-      resolve(true);
-    });
-  });
-
-}
-
-module.exports = { getLayers, allLayersExist, getPublicLayers, isPublic };
\ No newline at end of file

src/baseStorage.js

+const config = require("../config");
+const { createStorage } = require("./storageFactory");
+
+class BaseStorage {
+
+  constructor(storage) {
+    this.storage = storage;
+  }
+
+  getLayers(ids, boundingbox) {
+    return this.storage.getLayers(ids, boundingbox);
+  }
+
+  getPublicLayers() {
+    return this.storage.getPublicLayers();
+  }
+
+  isPublic(url) {
+    return this.storage.isPublic(url);
+  }
+
+  validateLayers(ids) {
+    return this.storage.validateLayers(ids);
+  }
+
+}
+
+class BaseStorageInstance {
+
+  constructor() {
+    if (!BaseStorageInstance.instance) {
+      const storage = createStorage(config.storage);
+      BaseStorageInstance.instance = new BaseStorage(storage)
+    }
+  }
+
+  getInstance() {
+    return BaseStorageInstance.instance;
+  }
+
+}
+
+module.exports = BaseStorageInstance;
\ No newline at end of file

src/getCapabilitiesHandler.js

-const assets = require("../src/assets");
 const pug = require("pug");
+const BaseStorage = require('./baseStorage');
+
+const storage = new BaseStorage().getInstance();
 
 const getCapabilitiesHandler = (req, res) => {
 
-  assets.getPublicLayers().then(layers => {
+  storage.getPublicLayers().then(layers => {
 
     const compiledFunction = pug.compileFile("./views/capabilities.pug");
     let capabilities = compiledFunction({ layers: layers });

src/getSceneHandler.js

-const assets = require("../src/assets");
+const BaseStorage = require('./baseStorage');
+
+const storage = new BaseStorage().getInstance();
 
 const getSceneHandler = (req, res) => {
 
-  assets.getLayers(req.query.layers, req.query.boundingbox).then(layers => {
+  storage.getLayers(req.query.layers, req.query.boundingbox).then(layers => {
 
     layers = layers.map(layer => {
       delete layer.scope;

src/storage.js

+const fs = require("fs");
+const boxIntersect = require("box-intersect");
+const path = require('path');
+
+class JSONStorage {
+
+  constructor(path) {
+    this.path = path;
+  }
+
+  getLayers(ids, boundingbox) {
+    if (boundingbox === undefined) {
+
+      return new Promise((resolve, reject) => {
+        fs.readFile(this.path, (err, data) => {
+          if (err) {
+            reject();
+          }
+          let assets = JSON.parse(data);
+          let requestedLayers = ids.split(",");
+          assets = assets.filter(asset => requestedLayers.includes(asset.id));
+          assets = assets.filter(asset => asset.scope == "public");
+          resolve(assets);
+        });
+      });
+
+    } else {
+
+      return this.getIntersectingLayers(ids, boundingbox);
+
+    }
+  }
+
+  getPublicLayers() {
+    return new Promise((resolve, reject) => {
+      fs.readFile(this.path, (err, data) => {
+        let assets = JSON.parse(data);
+        assets = assets.filter(asset => asset.scope == "public");
+        resolve(assets);
+      });
+    });
+  }
+
+  isPublic(url) {
+    return new Promise((resolve, reject) => {
+      fs.readFile(this.path, (err, data) => {
+        let assets = JSON.parse(data);
+        assets = assets.filter(asset => {
+          let parentDir = path.dirname(asset.url);
+          return !path.relative(parentDir, url).startsWith("..");
+        });
+        if (assets.length == 0) {
+          resolve(false);
+          return;
+        }
+        if (!assets[0].scope == "public") {
+          resolve(false);
+          return;
+        }
+        resolve(true);
+      });
+    });
+  }
+
+  validateLayers(ids) {
+    if (!ids) return Promise.reject();
+
+    return new Promise((resolve, reject) => {
+      fs.readFile(this.path, (err, data) => {
+        if (err) {
+          reject();
+        }
+        let assets = JSON.parse(data);
+        let layers = ids.split(",");
+        layers.forEach(layer => {
+          if (assets.findIndex(asset => asset.id == layer) == -1) {
+            reject();
+          }
+        });
+        resolve();
+      });
+    });
+  }
+
+  getIntersectingLayers(ids, bb) {
+
+    return new Promise((resolve, reject) => {
+      fs.readFile(this.path, (err, data) => {
+        if (err) {
+          reject();
+        }
+        let assets = JSON.parse(data);
+        let requestedBB = bb.split(",").map(token => parseFloat(token));
+        let requestedLayers = ids.split(",");
+
+        assets = assets.filter(asset => requestedLayers.includes(asset.id));
+        assets = assets.filter(asset => asset.scope == "public");
+
+        assets = assets.filter(asset => {
+
+          let overlaps = boxIntersect([
+            [...asset.boundingbox],
+            [...requestedBB]
+          ]);
+
+          if (overlaps.length > 0) {
+            return true;
+          }
+          return false;
+        });
+
+        resolve(assets);
+
+      });
+    });
+
+  }
+
+}
+
+module.exports = JSONStorage;
\ No newline at end of file

src/storageFactory.js

+const JSONStorage = require("./storage");
+
+const createStorage = (params) => {
+
+  switch (params.type) {
+
+    case "JSON": {
+
+      return new JSONStorage(params.path);
+
+    }
+
+  }
+
+}
+
+module.exports = {createStorage};
\ No newline at end of file

src/validationCheckFactory.js

 const { query } = require("express-validator");
 const { toLower, toUpper, boundingboxIsValid } = require("../src/customSanitizers");
-const assets = require("../src/assets");
+const BaseStorage = require('./baseStorage');
+
+const storage = new BaseStorage().getInstance();
 
 const commonChecks = () => {
   return [
@@ -37,7 +39,7 @@ const getChecksFor = (parameter) => {
           .matches(/^EPSG:\d{4,5}$/).withMessage("InvalidParameterValue"),
         query("layers")
           .exists().withMessage("MissingParameterValue")
-          .custom(value => assets.allLayersExist(value)).withMessage("UnknownLayer"),
+          .custom(value => storage.validateLayers(value)).withMessage("UnknownLayer"),
         query("boundingbox")
           .optional()
           .matches(/^((\-?\d+(\.\d+)?),){3}(\-?\d+(\.\d+)?)$/).withMessage("InvalidParameterValue")