tileserver-gl-light 4.5.2 → 4.6.0

package/src/serve_data.js

@@ -10,7 +10,12 @@ import MBTiles from '@mapbox/mbtiles';
 import Pbf from 'pbf';
 import { VectorTile } from '@mapbox/vector-tile';
 
-import { getTileUrls, fixTileJSONCenter } from './utils.js';
+import { getTileUrls, isValidHttpUrl, fixTileJSONCenter } from './utils.js';
+import {
+  PMtilesOpen,
+  GetPMtilesInfo,
+  GetPMtilesTile,
+} from './pmtiles_adapter.js';
 
 export const serve_data = {
   init: (options, repo) => {
@@ -18,7 +23,7 @@ export const serve_data = {
 
     app.get(
       '/:id/:z(\\d+)/:x(\\d+)/:y(\\d+).:format([\\w.]+)',
-      (req, res, next) => {
+      async (req, res, next) => {
         const item = repo[req.params.id];
         if (!item) {
           return res.sendStatus(404);
@@ -48,71 +53,118 @@ export const serve_data = {
         ) {
           return res.status(404).send('Out of bounds');
         }
-        item.source.getTile(z, x, y, (err, data, headers) => {
-          let isGzipped;
-          if (err) {
-            if (/does not exist/.test(err.message)) {
-              return res.status(204).send();
-            } else {
-              return res
-                .status(500)
-                .header('Content-Type', 'text/plain')
-                .send(err.message);
-            }
+        if (item.source_type === 'pmtiles') {
+          let tileinfo = await GetPMtilesTile(item.source, z, x, y);
+          if (tileinfo == undefined || tileinfo.data == undefined) {
+            return res.status(404).send('Not found');
           } else {
-            if (data == null) {
-              return res.status(404).send('Not found');
+            let data = tileinfo.data;
+            let headers = tileinfo.header;
+            if (tileJSONFormat === 'pbf') {
+              if (options.dataDecoratorFunc) {
+                data = options.dataDecoratorFunc(id, 'data', data, z, x, y);
+              }
+            }
+            if (format === 'pbf') {
+              headers['Content-Type'] = 'application/x-protobuf';
+            } else if (format === 'geojson') {
+              headers['Content-Type'] = 'application/json';
+
+              if (isGzipped) {
+                data = zlib.unzipSync(data);
+                isGzipped = false;
+              }
+
+              const tile = new VectorTile(new Pbf(data));
+              const geojson = {
+                type: 'FeatureCollection',
+                features: [],
+              };
+              for (const layerName in tile.layers) {
+                const layer = tile.layers[layerName];
+                for (let i = 0; i < layer.length; i++) {
+                  const feature = layer.feature(i);
+                  const featureGeoJSON = feature.toGeoJSON(x, y, z);
+                  featureGeoJSON.properties.layer = layerName;
+                  geojson.features.push(featureGeoJSON);
+                }
+              }
+              data = JSON.stringify(geojson);
+            }
+            delete headers['ETag']; // do not trust the tile ETag -- regenerate
+            headers['Content-Encoding'] = 'gzip';
+            res.set(headers);
+
+            data = zlib.gzipSync(data);
+
+            return res.status(200).send(data);
+          }
+        } else if (item.source_type === 'mbtiles') {
+          item.source.getTile(z, x, y, (err, data, headers) => {
+            let isGzipped;
+            if (err) {
+              if (/does not exist/.test(err.message)) {
+                return res.status(204).send();
+              } else {
+                return res
+                  .status(500)
+                  .header('Content-Type', 'text/plain')
+                  .send(err.message);
+              }
             } else {
-              if (tileJSONFormat === 'pbf') {
-                isGzipped =
-                  data.slice(0, 2).indexOf(Buffer.from([0x1f, 0x8b])) === 0;
-                if (options.dataDecoratorFunc) {
+              if (data == null) {
+                return res.status(404).send('Not found');
+              } else {
+                if (tileJSONFormat === 'pbf') {
+                  isGzipped =
+                    data.slice(0, 2).indexOf(Buffer.from([0x1f, 0x8b])) === 0;
+                  if (options.dataDecoratorFunc) {
+                    if (isGzipped) {
+                      data = zlib.unzipSync(data);
+                      isGzipped = false;
+                    }
+                    data = options.dataDecoratorFunc(id, 'data', data, z, x, y);
+                  }
+                }
+                if (format === 'pbf') {
+                  headers['Content-Type'] = 'application/x-protobuf';
+                } else if (format === 'geojson') {
+                  headers['Content-Type'] = 'application/json';
+
                   if (isGzipped) {
                     data = zlib.unzipSync(data);
                     isGzipped = false;
                   }
-                  data = options.dataDecoratorFunc(id, 'data', data, z, x, y);
-                }
-              }
-              if (format === 'pbf') {
-                headers['Content-Type'] = 'application/x-protobuf';
-              } else if (format === 'geojson') {
-                headers['Content-Type'] = 'application/json';
-
-                if (isGzipped) {
-                  data = zlib.unzipSync(data);
-                  isGzipped = false;
-                }
 
-                const tile = new VectorTile(new Pbf(data));
-                const geojson = {
-                  type: 'FeatureCollection',
-                  features: [],
-                };
-                for (const layerName in tile.layers) {
-                  const layer = tile.layers[layerName];
-                  for (let i = 0; i < layer.length; i++) {
-                    const feature = layer.feature(i);
-                    const featureGeoJSON = feature.toGeoJSON(x, y, z);
-                    featureGeoJSON.properties.layer = layerName;
-                    geojson.features.push(featureGeoJSON);
+                  const tile = new VectorTile(new Pbf(data));
+                  const geojson = {
+                    type: 'FeatureCollection',
+                    features: [],
+                  };
+                  for (const layerName in tile.layers) {
+                    const layer = tile.layers[layerName];
+                    for (let i = 0; i < layer.length; i++) {
+                      const feature = layer.feature(i);
+                      const featureGeoJSON = feature.toGeoJSON(x, y, z);
+                      featureGeoJSON.properties.layer = layerName;
+                      geojson.features.push(featureGeoJSON);
+                    }
                   }
+                  data = JSON.stringify(geojson);
                 }
-                data = JSON.stringify(geojson);
-              }
-              delete headers['ETag']; // do not trust the tile ETag -- regenerate
-              headers['Content-Encoding'] = 'gzip';
-              res.set(headers);
+                delete headers['ETag']; // do not trust the tile ETag -- regenerate
+                headers['Content-Encoding'] = 'gzip';
+                res.set(headers);
 
-              if (!isGzipped) {
-                data = zlib.gzipSync(data);
-                isGzipped = true;
-              }
+                if (!isGzipped) {
+                  data = zlib.gzipSync(data);
+                }
 
-              return res.status(200).send(data);
+                return res.status(200).send(data);
+              }
             }
-          }
-        });
+          });
+        }
       },
     );
 
@@ -137,55 +189,103 @@ export const serve_data = {
 
     return app;
   },
-  add: (options, repo, params, id, publicUrl) => {
-    const mbtilesFile = path.resolve(options.paths.mbtiles, params.mbtiles);
+  add: async (options, repo, params, id, publicUrl) => {
+    let inputFile;
+    let inputType;
+    if (params.pmtiles) {
+      inputType = 'pmtiles';
+      if (isValidHttpUrl(params.pmtiles)) {
+        inputFile = params.pmtiles;
+      } else {
+        inputFile = path.resolve(options.paths.pmtiles, params.pmtiles);
+      }
+    } else if (params.mbtiles) {
+      inputType = 'mbtiles';
+      if (isValidHttpUrl(params.mbtiles)) {
+        console.log(
+          `ERROR: MBTiles does not support web based files. "${params.mbtiles}" is not a valid data file.`,
+        );
+        process.exit(1);
+      } else {
+        inputFile = path.resolve(options.paths.mbtiles, params.mbtiles);
+      }
+    }
+
     let tileJSON = {
       tiles: params.domains || options.domains,
     };
 
-    const mbtilesFileStats = fs.statSync(mbtilesFile);
-    if (!mbtilesFileStats.isFile() || mbtilesFileStats.size === 0) {
-      throw Error(`Not valid MBTiles file: ${mbtilesFile}`);
+    if (!isValidHttpUrl(inputFile)) {
+      const inputFileStats = fs.statSync(inputFile);
+      if (!inputFileStats.isFile() || inputFileStats.size === 0) {
+        throw Error(`Not valid input file: "${inputFile}"`);
+      }
     }
+
     let source;
-    const sourceInfoPromise = new Promise((resolve, reject) => {
-      source = new MBTiles(mbtilesFile + '?mode=ro', (err) => {
-        if (err) {
-          reject(err);
-          return;
-        }
-        source.getInfo((err, info) => {
+    let source_type;
+    if (inputType === 'pmtiles') {
+      source = PMtilesOpen(inputFile);
+      source_type = 'pmtiles';
+      const metadata = await GetPMtilesInfo(source);
+
+      tileJSON['name'] = id;
+      tileJSON['format'] = 'pbf';
+      Object.assign(tileJSON, metadata);
+
+      tileJSON['tilejson'] = '2.0.0';
+      delete tileJSON['filesize'];
+      delete tileJSON['mtime'];
+      delete tileJSON['scheme'];
+
+      Object.assign(tileJSON, params.tilejson || {});
+      fixTileJSONCenter(tileJSON);
+
+      if (options.dataDecoratorFunc) {
+        tileJSON = options.dataDecoratorFunc(id, 'tilejson', tileJSON);
+      }
+    } else if (inputType === 'mbtiles') {
+      source_type = 'mbtiles';
+      const sourceInfoPromise = new Promise((resolve, reject) => {
+        source = new MBTiles(inputFile + '?mode=ro', (err) => {
           if (err) {
             reject(err);
             return;
           }
-          tileJSON['name'] = id;
-          tileJSON['format'] = 'pbf';
+          source.getInfo((err, info) => {
+            if (err) {
+              reject(err);
+              return;
+            }
+            tileJSON['name'] = id;
+            tileJSON['format'] = 'pbf';
 
-          Object.assign(tileJSON, info);
+            Object.assign(tileJSON, info);
 
-          tileJSON['tilejson'] = '2.0.0';
-          delete tileJSON['filesize'];
-          delete tileJSON['mtime'];
-          delete tileJSON['scheme'];
+            tileJSON['tilejson'] = '2.0.0';
+            delete tileJSON['filesize'];
+            delete tileJSON['mtime'];
+            delete tileJSON['scheme'];
 
-          Object.assign(tileJSON, params.tilejson || {});
-          fixTileJSONCenter(tileJSON);
+            Object.assign(tileJSON, params.tilejson || {});
+            fixTileJSONCenter(tileJSON);
 
-          if (options.dataDecoratorFunc) {
-            tileJSON = options.dataDecoratorFunc(id, 'tilejson', tileJSON);
-          }
-          resolve();
+            if (options.dataDecoratorFunc) {
+              tileJSON = options.dataDecoratorFunc(id, 'tilejson', tileJSON);
+            }
+            resolve();
+          });
         });
       });
-    });
 
-    return sourceInfoPromise.then(() => {
-      repo[id] = {
-        tileJSON,
-        publicUrl,
-        source,
-      };
-    });
+      await sourceInfoPromise;
+    }
+
+    repo[id] = {
+      tileJSON,
+      publicUrl,
+      source,
+      source_type,
+    };
   },
 };