tileserver-gl 5.7.0-pre.0 → 5.7.0

package/src/server.js

@@ -23,13 +23,9 @@ import {
   getPublicUrl,
   isValidHttpUrl,
   isValidRemoteUrl,
-  parseAllowedHosts,
-  isHostAllowed,
-  getCandidateHost,
-  getSafeProtocol,
 } from './utils.js';
 
-import { fileURLToPath } from 'url';
+import { fileURLToPath, pathToFileURL } from 'url';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const packageJson = JSON.parse(
   fs.readFileSync(__dirname + '/../package.json', 'utf8'),
@@ -194,7 +190,10 @@ async function start(opts) {
     try {
       const dataDecoratorPath = path.resolve(paths.root, options.dataDecorator);
 
-      const module = await import(dataDecoratorPath);
+      // import() needs a file:// URL, not a bare path: on Windows an absolute
+      // path starts with a drive letter and the ESM loader rejects it as an
+      // unknown URL scheme, so the decorator silently never loaded there.
+      const module = await import(pathToFileURL(dataDecoratorPath).href);
       options.dataDecoratorFunc = module.default;
     } catch (e) {
       console.error(`Error loading data decorator: ${e}`);
@@ -452,9 +451,10 @@ async function start(opts) {
                       resolvedS3Region = sourceData.s3Region;
                     }
 
-                    // Get sparse: per-source overrides global, default to true
-                    resolvedSparse =
-                      sourceData.sparse ?? options.sparse ?? true;
+                    // Pass the source's own setting through untouched. The
+                    // global option and the format-based default are applied
+                    // by resolveSparse() where the tile format is known.
+                    resolvedSparse = sourceData.sparse;
 
                     break; // Found our match, exit the outer loop
                   }
@@ -482,7 +482,7 @@ async function start(opts) {
                   requestPayer: false,
                   s3Region: undefined,
                   s3UrlFormat: undefined,
-                  sparse: true,
+                  sparse: undefined,
                 };
               }
 

package/src/utils.js

@@ -666,3 +666,54 @@ export async function fetchTileData(source, sourceType, z, x, y) {
     });
   }
 }
+
+/**
+ * Reads a flag that may arrive as a boolean or as text.
+ *
+ * mbtiles metadata is a table of strings, so a `sparse` row reaches us as
+ * `"false"` - truthy if taken at face value. PMTiles metadata is JSON and can
+ * hold a real boolean. Anything unrecognised is treated as absent rather than
+ * guessed at, so a typo falls through to the next level of precedence instead
+ * of silently meaning `true`.
+ * @param {unknown} value - The raw value.
+ * @returns {boolean|undefined} The boolean, or undefined if absent/unrecognised.
+ */
+export function parseOptionalBoolean(value) {
+  if (typeof value === 'boolean') {
+    return value;
+  }
+  if (typeof value === 'string') {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'true' || normalized === '1') {
+      return true;
+    }
+    if (normalized === 'false' || normalized === '0') {
+      return false;
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Resolves whether a source should answer a missing tile sparsely.
+ *
+ * Precedence, highest first: the per-source config setting, the global config
+ * option, the archive's own metadata, then a format-based default - raster
+ * sources are sparse so MapLibre overzooms from the parent, vector sources are
+ * not so an empty tile stops the overzoom. Config outranks metadata because an
+ * operator can change their config but not always the archive.
+ *
+ * Nullish coalescing is deliberate: an explicit `false` at any level must win
+ * over the level below it. Named arguments, because four booleans in a row is
+ * an argument-order bug waiting to happen and two of the levels are often
+ * absent.
+ * @param {object} levels - The values to resolve between.
+ * @param {boolean} [levels.perSource] - The source's own `sparse` config setting.
+ * @param {boolean} [levels.globalOption] - The top-level `sparse` option.
+ * @param {boolean} [levels.metadata] - `sparse` from the archive's metadata.
+ * @param {boolean} levels.isVector - Whether the source serves vector tiles.
+ * @returns {boolean} True when a missing tile should answer 404 rather than 204.
+ */
+export function resolveSparse({ perSource, globalOption, metadata, isVector }) {
+  return perSource ?? globalOption ?? metadata ?? !isVector;
+}

package/test/data_decorator.js

@@ -0,0 +1,156 @@
+import { server } from '../src/server.js';
+
+const SIGNALS = ['SIGHUP', 'SIGINT', 'SIGTERM'];
+
+// Resolved against paths.root, which is the cwd (test_data) when the config is
+// passed as an object rather than a file.
+const DECORATOR = '../test/fixtures/data-decorator.js';
+
+describe('data decorator', function () {
+  let running;
+  let listenerBaseline;
+
+  before(async function () {
+    globalThis.__dataDecoratorCalls = [];
+    listenerBaseline = SIGNALS.map((eventName) => ({
+      eventName,
+      count: process.listeners(eventName).length,
+    }));
+
+    running = await server({
+      config: {
+        options: {
+          paths: { fonts: 'fonts', styles: 'styles' },
+          dataDecorator: DECORATOR,
+        },
+        // The style pulls in the same source through a mbtiles:// url, which
+        // is the path serve_rendered decorates.
+        styles: { 'test-style': { style: 'osm-bright/style.json' } },
+        data: { openmaptiles: { mbtiles: 'zurich_switzerland.mbtiles' } },
+      },
+      port: 0,
+      publicUrl: '/test/',
+    });
+    await running.startupPromise;
+  });
+
+  after(async function () {
+    await running.cleanup();
+    if (running.server.listening) {
+      await new Promise((resolve) => running.server.close(resolve));
+    }
+    for (const { eventName, count } of listenerBaseline) {
+      for (const listener of process.listeners(eventName).slice(count)) {
+        process.removeListener(eventName, listener);
+      }
+    }
+    delete globalThis.__dataDecoratorCalls;
+  });
+
+  // Regression test: the decorator path is absolute, and on Windows that means
+  // it starts with a drive letter. import() rejects that as an unknown URL
+  // scheme, and the failure is swallowed by a try/catch, so the decorator was
+  // never called at all and the server started as though none was configured.
+  it('loads and is called for a configured data source', function () {
+    const calls = globalThis.__dataDecoratorCalls;
+    expect(calls).to.be.an('array');
+    expect(calls.length).to.be.greaterThan(0);
+    expect(calls.map((c) => c.id)).to.include('openmaptiles');
+  });
+
+  it('receives the TileJSON it is meant to decorate', function () {
+    const tilejsonCall = globalThis.__dataDecoratorCalls.find(
+      (c) => c.type === 'tilejson' && c.id === 'openmaptiles',
+    );
+    expect(tilejsonCall, 'no tilejson call recorded').to.not.equal(undefined);
+    expect(tilejsonCall.format).to.equal('pbf');
+  });
+
+  it('uses what the decorator returned, not the object it was handed', function (done) {
+    // The fixture returns a new object rather than mutating in place. Recording
+    // that the decorator ran is not enough - its return value has to be the one
+    // that reaches the response.
+    supertest(running.app)
+      .get('/data/openmaptiles.json')
+      .expect(200)
+      .expect((res) => {
+        expect(
+          res.body.decorated,
+          'decorator return value was dropped',
+        ).to.equal(true);
+        expect(res.body.format, 'TileJSON lost its own fields').to.equal('pbf');
+      })
+      .end(done);
+  });
+
+  it('is applied to the local sources a style pulls in', function () {
+    // serve_rendered decorates each local source of a style. That call carries
+    // the source object, whose tiles url is the internal mbtiles:// form - the
+    // only thing distinguishing it from the /data tilejson call for the same id.
+    const styleSourceCall = globalThis.__dataDecoratorCalls.find(
+      (c) =>
+        c.type === 'tilejson' &&
+        Array.isArray(c.tiles) &&
+        c.tiles.some((t) => t.startsWith('mbtiles://openmaptiles/')),
+    );
+    expect(styleSourceCall, 'style source was never decorated').to.not.equal(
+      undefined,
+    );
+    expect(styleSourceCall.id).to.equal('openmaptiles');
+  });
+});
+
+describe('async data decorator', function () {
+  let running;
+  let listenerBaseline;
+
+  before(async function () {
+    listenerBaseline = SIGNALS.map((eventName) => ({
+      eventName,
+      count: process.listeners(eventName).length,
+    }));
+    running = await server({
+      config: {
+        options: {
+          paths: { fonts: 'fonts', styles: 'styles' },
+          dataDecorator: '../test/fixtures/data-decorator-async.js',
+        },
+        data: { openmaptiles: { mbtiles: 'zurich_switzerland.mbtiles' } },
+      },
+      port: 0,
+      publicUrl: '/test/',
+    });
+    await running.startupPromise;
+  });
+
+  after(async function () {
+    await running.cleanup();
+    if (running.server.listening) {
+      await new Promise((resolve) => running.server.close(resolve));
+    }
+    for (const { eventName, count } of listenerBaseline) {
+      for (const listener of process.listeners(eventName).slice(count)) {
+        process.removeListener(eventName, listener);
+      }
+    }
+  });
+
+  // Without an await at the call site the decorator's promise is assigned
+  // straight to the TileJSON, which then serves as {tiles: [...]} with every
+  // other field gone - a 200 carrying silently emptied data.
+  it('awaits a decorator that returns a promise', function (done) {
+    supertest(running.app)
+      .get('/data/openmaptiles.json')
+      .expect(200)
+      .expect((res) => {
+        expect(
+          res.body.decoratedAsync,
+          'async decorator was not awaited',
+        ).to.equal(true);
+        expect(res.body.format, 'TileJSON was replaced by a promise').to.equal(
+          'pbf',
+        );
+      })
+      .end(done);
+  });
+});

package/test/fixtures/data-decorator-async.js

@@ -0,0 +1,17 @@
+// Async data decorator fixture. Resolves on a later tick before returning, so
+// a caller that does not await it gets a promise rather than the data.
+
+/**
+ * Marks the TileJSON after yielding to the event loop.
+ * @param {string} id - The data source id.
+ * @param {string} type - What is being decorated, e.g. 'tilejson' or 'data'.
+ * @param {unknown} data - The value being decorated.
+ * @returns {Promise<unknown>} The data, marked when it is TileJSON.
+ */
+export default async function decorate(id, type, data) {
+  await new Promise((resolve) => setTimeout(resolve, 1));
+  if (type === 'tilejson' && data && typeof data === 'object') {
+    return { ...data, decoratedAsync: true };
+  }
+  return data;
+}

package/test/fixtures/data-decorator.js

@@ -0,0 +1,29 @@
+// Data decorator fixture. Records every call on globalThis so the test can
+// assert what the server handed it, then passes the data through untouched.
+
+/**
+ * Records the call and returns the data unchanged.
+ * @param {string} id - The data source id.
+ * @param {string} type - What is being decorated, e.g. 'tilejson' or 'data'.
+ * @param {unknown} data - The value being decorated.
+ * @returns {unknown} The data, unmodified.
+ */
+export default function decorate(id, type, data) {
+  globalThis.__dataDecoratorCalls = globalThis.__dataDecoratorCalls || [];
+  globalThis.__dataDecoratorCalls.push({
+    id,
+    type,
+    // Snapshot rather than store the live object, which the server mutates
+    // after the decorator returns.
+    sparse: data && data.sparse,
+    sparseType: typeof (data && data.sparse),
+    tiles: data && data.tiles,
+    format: data && data.format,
+  });
+  // Return a *new* object for tilejson, so a caller that only reassigns its
+  // local variable visibly loses the change.
+  if (type === 'tilejson' && data && typeof data === 'object') {
+    return { ...data, decorated: true };
+  }
+  return data;
+}

package/test/render_mode.js

@@ -0,0 +1,48 @@
+import assert from 'node:assert/strict';
+import {
+  getMapLibreRenderZoom,
+  getStaticOverlayZoom,
+} from '../src/render_mode.js';
+
+describe('MapLibre render zoom', function () {
+  it('uses the overlay-aligned zoom for a 512px static map', function () {
+    assert.equal(getMapLibreRenderZoom(12, 512, 'static'), 11);
+  });
+
+  it('uses the overlay-aligned zoom for a 400px static map', function () {
+    assert.equal(getMapLibreRenderZoom(12, 400, 'static'), 11);
+  });
+
+  it('uses the 256px tile zoom for a 256px tile', function () {
+    assert.equal(getMapLibreRenderZoom(12, 256, 'tile'), 11);
+  });
+
+  it('uses the 512px tile zoom for a 512px tile', function () {
+    assert.equal(getMapLibreRenderZoom(12, 512, 'tile'), 12);
+  });
+
+  it('rejects an unsupported render mode', function () {
+    assert.throws(
+      () => getMapLibreRenderZoom(12, 512, 'preview'),
+      /Unsupported render mode: preview/,
+    );
+  });
+});
+
+describe('Static overlay zoom', function () {
+  it('raises the zoom when the world would not fill the viewport height', function () {
+    assert.equal(getStaticOverlayZoom(1, 600, 600), Math.log2(600 / 256));
+  });
+
+  it('does not raise the zoom for a wide but short viewport', function () {
+    assert.equal(getStaticOverlayZoom(1, 1000, 500), 1);
+  });
+
+  it('preserves a requested zoom above the viewport minimum', function () {
+    assert.equal(getStaticOverlayZoom(12, 1000, 1000), 12);
+  });
+
+  it('preserves the dedicated 256px zoom-zero render path', function () {
+    assert.equal(getStaticOverlayZoom(0, 256, 256), 0);
+  });
+});