Upgrade Express to v5 +Canvas v3 + code cleanup

package.json

@@ -33,7 +33,7 @@
     "color": "4.2.3",
     "commander": "12.1.0",
     "cors": "2.8.5",
-    "express": "4.19.2",
+    "express": "5.0.1",
     "handlebars": "4.7.8",
     "http-shutdown": "1.2.2",
     "morgan": "1.10.0",

src/main.js

@@ -1,6 +1,12 @@
 #!/usr/bin/env node
 
 'use strict';
+import os from 'os';
+
+const envSize = parseInt(process.env.UV_THREADPOOL_SIZE, 10);
+process.env.UV_THREADPOOL_SIZE = Math.ceil(
+  Math.max(4, isNaN(envSize) ? os.cpus().length * 1.5 : envSize),
+);
 
 import fs from 'node:fs';
 import fsp from 'node:fs/promises';

src/serve_data.js

@@ -18,151 +18,153 @@ import { gunzipP, gzipP } from './promises.js';
 import { openMbTilesWrapper } from './mbtiles_wrapper.js';
 
 export const serve_data = {
-  init: (options, repo) => {
+  /**
+   * Initializes the serve_data module.
+   * @param {object} options Configuration options.
+   * @param {object} repo Repository object.
+   * @returns {express.Application} The initialized Express application.
+   */
+  init: function (options, repo) {
     const app = express().disable('x-powered-by');
 
-    app.get(
-      '/:id/:z(\\d+)/:x(\\d+)/:y(\\d+).:format([\\w.]+)',
-      async (req, res, next) => {
-        const item = repo[req.params.id];
-        if (!item) {
-          return res.sendStatus(404);
-        }
-        const tileJSONFormat = item.tileJSON.format;
-        const z = req.params.z | 0;
-        const x = req.params.x | 0;
-        const y = req.params.y | 0;
-        let format = req.params.format;
-        if (format === options.pbfAlias) {
-          format = 'pbf';
-        }
-        if (
-          format !== tileJSONFormat &&
-          !(format === 'geojson' && tileJSONFormat === 'pbf')
-        ) {
-          return res.status(404).send('Invalid format');
-        }
-        if (
-          z < item.tileJSON.minzoom ||
-          0 ||
-          x < 0 ||
-          y < 0 ||
-          z > item.tileJSON.maxzoom ||
-          x >= Math.pow(2, z) ||
-          y >= Math.pow(2, z)
-        ) {
-          return res.status(404).send('Out of bounds');
-        }
-        if (item.sourceType === 'pmtiles') {
-          let tileinfo = await getPMtilesTile(item.source, z, x, y);
-          if (tileinfo == undefined || tileinfo.data == undefined) {
-            return res.status(404).send('Not found');
-          } else {
-            let data = tileinfo.data;
-            let headers = tileinfo.header;
-            if (tileJSONFormat === 'pbf') {
-              if (options.dataDecoratorFunc) {
-                data = options.dataDecoratorFunc(id, 'data', data, z, x, y);
-              }
+    app.get('/:id/:z/:x/:y.:format', async (req, res) => {
+      const item = repo[req.params.id];
+      if (!item) {
+        return res.sendStatus(404);
+      }
+      const tileJSONFormat = item.tileJSON.format;
+      const z = parseFloat(req.params.z) | 0;
+      const x = parseFloat(req.params.x) | 0;
+      const y = parseFloat(req.params.y) | 0;
+      let format = req.params.format;
+      if (format === options.pbfAlias) {
+        format = 'pbf';
+      }
+      if (
+        format !== tileJSONFormat &&
+        !(format === 'geojson' && tileJSONFormat === 'pbf')
+      ) {
+        return res.status(404).send('Invalid format');
+      }
+      if (
+        z < item.tileJSON.minzoom ||
+        0 ||
+        x < 0 ||
+        y < 0 ||
+        z > item.tileJSON.maxzoom ||
+        x >= Math.pow(2, z) ||
+        y >= Math.pow(2, z)
+      ) {
+        return res.status(404).send('Out of bounds');
+      }
+      if (item.sourceType === 'pmtiles') {
+        let tileinfo = await getPMtilesTile(item.source, z, x, y);
+        if (tileinfo == undefined || tileinfo.data == undefined) {
+          return res.status(404).send('Not found');
+        } else {
+          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';
-              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);
-                }
+          }
+          if (format === 'pbf') {
+            headers['Content-Type'] = 'application/x-protobuf';
+          } else if (format === 'geojson') {
+            headers['Content-Type'] = 'application/json';
+            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 = JSON.stringify(geojson);
+          }
+          delete headers['ETag']; // do not trust the tile ETag -- regenerate
+          headers['Content-Encoding'] = 'gzip';
+          res.set(headers);
 
-            data = await gzipP(data);
+          data = await gzipP(data);
 
-            return res.status(200).send(data);
-          }
-        } else if (item.sourceType === 'mbtiles') {
-          item.source.getTile(z, x, y, async (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);
-              }
+          return res.status(200).send(data);
+        }
+      } else if (item.sourceType === 'mbtiles') {
+        item.source.getTile(z, x, y, async (err, data, headers) => {
+          let isGzipped;
+          if (err) {
+            if (/does not exist/.test(err.message)) {
+              return res.status(204).send();
             } else {
-              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 = await gunzipP(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';
-
+              return res
+                .status(500)
+                .header('Content-Type', 'text/plain')
+                .send(err.message);
+            }
+          } else {
+            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 = await gunzipP(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';
 
-                  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);
+                if (isGzipped) {
+                  data = await gunzipP(data);
+                  isGzipped = false;
                 }
-                delete headers['ETag']; // do not trust the tile ETag -- regenerate
-                headers['Content-Encoding'] = 'gzip';
-                res.set(headers);
 
-                if (!isGzipped) {
-                  data = await gzipP(data);
+                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);
 
-                return res.status(200).send(data);
+              if (!isGzipped) {
+                data = await gzipP(data);
               }
-            }
-          });
-        }
-      },
-    );
 
-    app.get('/:id.json', (req, res, next) => {
+              return res.status(200).send(data);
+            }
+          }
+        });
+      }
+    });
+    app.get('/:id.json', (req, res) => {
       const item = repo[req.params.id];
       if (!item) {
         return res.sendStatus(404);
@@ -185,7 +187,16 @@ export const serve_data = {
 
     return app;
   },
-  add: async (options, repo, params, id, publicUrl) => {
+  /**
+   * Adds a new data source to the repository.
+   * @param {object} options Configuration options.
+   * @param {object} repo Repository object.
+   * @param {object} params Parameters object.
+   * @param {string} id ID of the data source.
+   * @param {string} publicUrl Public URL of the data.
+   * @returns {Promise<void>}
+   */
+  add: async function (options, repo, params, id, publicUrl) {
     let inputFile;
     let inputType;
     if (params.pmtiles) {

src/serve_font.js

@@ -4,7 +4,13 @@ import express from 'express';
 
 import { getFontsPbf, listFonts } from './utils.js';
 
-export const serve_font = async (options, allowedFonts) => {
+/**
+ * Initializes and returns an Express app that serves font files.
+ * @param {object} options - Configuration options for the server.
+ * @param {object} allowedFonts - An object containing allowed fonts.
+ * @returns {Promise<express.Application>} - A promise that resolves to the Express app.
+ */
+export async function serve_font(options, allowedFonts) {
   const app = express().disable('x-powered-by');
 
   const lastModified = new Date().toUTCString();
@@ -13,31 +19,29 @@ export const serve_font = async (options, allowedFonts) => {
 
   const existingFonts = {};
 
-  app.get(
-    '/fonts/:fontstack/:range([\\d]+-[\\d]+).pbf',
-    async (req, res, next) => {
-      const fontstack = decodeURI(req.params.fontstack);
-      const range = req.params.range;
-
-      try {
-        const concatenated = await getFontsPbf(
-          options.serveAllFonts ? null : allowedFonts,
-          fontPath,
-          fontstack,
-          range,
-          existingFonts,
-        );
-
-        res.header('Content-type', 'application/x-protobuf');
-        res.header('Last-Modified', lastModified);
-        return res.send(concatenated);
-      } catch (err) {
-        res.status(400).header('Content-Type', 'text/plain').send(err);
-      }
-    },
-  );
-
-  app.get('/fonts.json', (req, res, next) => {
+  app.get('/fonts/:fontstack/:range.pbf', async (req, res) => {
+    const fontstack = decodeURI(req.params.fontstack);
+    const range = req.params.range;
+
+    try {
+      const concatenated = await getFontsPbf(
+        options.serveAllFonts ? null : allowedFonts,
+        fontPath,
+        fontstack,
+        range,
+        existingFonts,
+      );
+
+      res.header('Content-type', 'application/x-protobuf');
+      res.header('Last-Modified', lastModified);
+      return res.send(concatenated);
+    } catch (err) {
+      console.error('Error serving font:', err);
+      return res.status(400).header('Content-Type', 'text/plain').send(err);
+    }
+  });
+
+  app.get('/fonts.json', (req, res) => {
     res.header('Content-type', 'application/json');
     return res.send(
       Object.keys(options.serveAllFonts ? existingFonts : allowedFonts).sort(),
@@ -47,4 +51,4 @@ export const serve_font = async (options, allowedFonts) => {
   const fonts = await listFonts(options.paths.fonts);
   Object.assign(existingFonts, fonts);
   return app;
-};
+}