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;