@basemaps/lambda-tiler 6.33.0 → 6.35.0

package/src/arcgis/vector.tile.server.ts

@@ -0,0 +1,81 @@
+import { TileSetType } from '@basemaps/config';
+import { GoogleTms } from '@basemaps/geo';
+import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import { convertRelativeUrl } from '../routes/tile.style.json.js';
+import { ConfigLoader } from '../util/config.loader.js';
+import { NotFound } from '../util/response.js';
+import { Validate } from '../util/validate.js';
+
+/** Zoom level for the tilematrix which will be slice by 1 during the covertion to arcgis tileserve lods */
+const MaxTileMatrixZoom = 18;
+const MinTileMatrixZoom = 1;
+
+export interface VectorTileServer {
+  Params: {
+    tileSet: string;
+  };
+}
+
+export async function arcgisTileServerGet(req: LambdaHttpRequest<VectorTileServer>): Promise<LambdaHttpResponse> {
+  const config = await ConfigLoader.load(req);
+
+  const tileSet = await config.TileSet.get(config.TileSet.id(req.params.tileSet));
+  if (tileSet?.type !== TileSetType.Vector) return NotFound();
+  const apiKey = Validate.apiKey(req);
+  const f = req.query.get('f');
+  if (f !== 'json') return NotFound();
+  const extent = {
+    xmin: GoogleTms.extent.x,
+    ymin: GoogleTms.extent.y,
+    xmax: GoogleTms.extent.right,
+    ymax: GoogleTms.extent.bottom,
+    // TODO where is wkid from
+    spatialReference: { wkid: 102100, latestWkid: GoogleTms.projection.code },
+  };
+  const vectorTileServer = {
+    currentVersion: 10.81,
+    name: tileSet.name,
+    capabilities: 'TilesOnly',
+    type: 'indexedVector',
+    defaultStyles: '',
+    tiles: [convertRelativeUrl(`/v1/tiles/${tileSet.name}/WebMercatorQuad/{z}/{x}/{y}.pbf`, apiKey)],
+    exportTilesAllowed: false,
+    maxExportTilesCount: 0,
+    initialExtent: extent,
+    fullExtent: extent,
+    minScale: 0.0,
+    maxScale: 0.0,
+    tileInfo: {
+      rows: 512,
+      cols: 512,
+      dpi: 96,
+      format: 'pbf',
+      origin: { x: GoogleTms.extent.x, y: GoogleTms.extent.bottom },
+      spatialReference: { wkid: 102100, latestWkid: GoogleTms.projection.code },
+      lods: GoogleTms.zooms.slice(MinTileMatrixZoom, MaxTileMatrixZoom).map((c, i) => {
+        return {
+          level: i,
+          resolution: c.scaleDenominator * 0.28e-3,
+          scale: c.scaleDenominator,
+        };
+      }),
+    },
+    maxzoom: 22,
+    minLOD: 0,
+    maxLOD: 15,
+    resourceInfo: {
+      styleVersion: 8,
+      tileCompression: 'gzip',
+      cacheInfo: { storageInfo: { packetSize: 128, storageFormat: 'compactV2' } },
+    },
+  };
+
+  const json = JSON.stringify(vectorTileServer, null, 2);
+  const data = Buffer.from(json);
+
+  const response = new LambdaHttpResponse(200, 'ok');
+  response.header(HttpHeader.CacheControl, 'no-store');
+  response.buffer(data, 'application/json');
+  req.set('bytes', data.byteLength);
+  return response;
+}

package/src/index.ts

@@ -1,6 +1,10 @@
 import { LogConfig } from '@basemaps/shared';
 import { LambdaHttpResponse, lf } from '@linzjs/lambda';
+import { arcgisInfoGet } from './arcgis/arcgis.info.js';
+import { arcgisStyleJsonGet } from './arcgis/arcgis.style.json.js';
+import { arcgisTileServerGet } from './arcgis/vector.tile.server.js';
 import { tileAttributionGet } from './routes/attribution.js';
+import { configImageryGet, configTileSetGet } from './routes/config.js';
 import { fontGet, fontList } from './routes/fonts.js';
 import { healthGet } from './routes/health.js';
 import { imageryGet } from './routes/imagery.js';
@@ -11,12 +15,15 @@ import { styleJsonGet } from './routes/tile.style.json.js';
 import { wmtsCapabilitiesGet } from './routes/tile.wmts.js';
 import { tileXyzGet } from './routes/tile.xyz.js';
 import { versionGet } from './routes/version.js';
-import { NotFound } from './util/response.js';
+import { NotFound, OkResponse } from './util/response.js';
 import { CoSources } from './util/source.cache.js';
 import { St } from './util/source.tracer.js';
 
 export const handler = lf.http(LogConfig.get());
 
+/** If the request takes too long, respond with a 408 timeout when there is approx 1 second remaining */
+handler.router.timeoutEarlyMs = 1_000;
+
 handler.router.hook('request', (req) => {
   req.set('name', 'LambdaTiler');
 
@@ -24,11 +31,7 @@ handler.router.hook('request', (req) => {
   St.reset();
 });
 
-let totalRequests = 0;
 handler.router.hook('response', (req, res) => {
-  totalRequests++;
-  req.set('requestsTotal', totalRequests); // Number of requests served by this lambda
-
   if (St.requests.length > 0) {
     // TODO this could be relaxed to every say 5% of requests if logging gets too verbose.
     req.set('requests', St.requests.slice(0, 100)); // limit to 100 requests (some tiles need 100s of requests)
@@ -68,6 +71,10 @@ handler.router.get('/v1/version', versionGet);
 // Image Metadata
 handler.router.get('/v1/imagery/:imageryId/:fileName', imageryGet);
 
+// Config
+handler.router.get('/v1/config/:tileSet.json', configTileSetGet);
+handler.router.get('/v1/config/:tileSet/:imageryId.json', configImageryGet);
+
 // Sprites
 handler.router.get('/v1/sprites/:spriteName', spriteGet);
 
@@ -94,3 +101,9 @@ handler.router.get('/v1/attribution/:tileSet/:tileMatrix/summary.json', tileAttr
 handler.router.get('/v1/tiles/:tileSet/:tileMatrix/WMTSCapabilities.xml', wmtsCapabilitiesGet);
 handler.router.get('/v1/tiles/:tileSet/WMTSCapabilities.xml', wmtsCapabilitiesGet);
 handler.router.get('/v1/tiles/WMTSCapabilities.xml', wmtsCapabilitiesGet);
+
+// Arcgis Vector
+handler.router.get('/v1/arcgis/rest/services/:tileSet/VectorTileServer', arcgisTileServerGet);
+handler.router.post('/v1/arcgis/rest/services/:tileSet/VectorTileServer', OkResponse);
+handler.router.get('/v1/arcgis/rest/services/:tileSet/VectorTileServer/root.json', arcgisStyleJsonGet);
+handler.router.get('/v1/arcgis/rest/info', arcgisInfoGet);

package/src/routes/__tests__/attribution.test.ts

@@ -1,11 +1,12 @@
 import { Attribution } from '@basemaps/attribution';
-import { Config, ConfigProviderMemory } from '@basemaps/config';
+import { ConfigProviderMemory } from '@basemaps/config';
 import { Nztm2000QuadTms } from '@basemaps/geo';
 import { LogConfig } from '@basemaps/shared';
 import { HttpHeader } from '@linzjs/lambda';
 import o from 'ospec';
 import sinon from 'sinon';
 import { handler } from '../../index.js';
+import { ConfigLoader } from '../../util/config.loader.js';
 import { FakeData, Imagery2193, Imagery3857, Provider, TileSetAerial } from '../../__tests__/config.data.js';
 import { mockUrlRequest } from '../../__tests__/xyz.util.js';
 
@@ -283,7 +284,8 @@ o.spec('/v1/attribution', () => {
 
   o.beforeEach(() => {
     LogConfig.get().level = 'silent';
-    Config.setConfigProvider(config);
+    sandbox.stub(ConfigLoader, 'getDefaultConfig').resolves(config);
+
     config.objects.clear();
 
     config.put(TileSetAerial);

package/src/routes/__tests__/fonts.test.ts

@@ -1,9 +1,12 @@
-import { Env } from '@basemaps/shared';
+import { base58, ConfigProviderMemory } from '@basemaps/config';
+import { Env, getDefaultConfig } from '@basemaps/shared';
 import { fsa } from '@chunkd/fs';
 import o from 'ospec';
 import { handler } from '../../index.js';
-import { mockRequest } from '../../__tests__/xyz.util.js';
-import { fontList, getFonts } from '../fonts.js';
+import { CachedConfig } from '../../util/config.cache.js';
+import { CoSources } from '../../util/source.cache.js';
+import { Api, mockRequest, mockUrlRequest } from '../../__tests__/xyz.util.js';
+import { fontList } from '../fonts.js';
 import { FsMemory } from './memory.fs.js';
 
 o.spec('/v1/fonts', () => {
@@ -11,52 +14,32 @@ o.spec('/v1/fonts', () => {
   o.before(() => {
     fsa.register('memory://', memory);
   });
+  const assetLocation = process.env[Env.AssetLocation];
 
   o.beforeEach(() => {
-    process.env[Env.AssetLocation] = 'memory://';
+    process.env[Env.AssetLocation] = 'memory://config';
+    getDefaultConfig().assets = 'memory://';
   });
 
   o.afterEach(() => {
-    delete process.env[Env.AssetLocation];
+    getDefaultConfig().assets = assetLocation;
+    CachedConfig.cache.clear();
+    CoSources.cache.clear();
     memory.files.clear();
   });
 
-  o('should list font types', async () => {
-    await Promise.all([
-      fsa.write('memory://fonts/Roboto Thin/0-255.pbf', Buffer.from('')),
-      fsa.write('memory://fonts/Roboto Thin/256-512.pbf', Buffer.from('')),
-      fsa.write('memory://fonts/Roboto Black/0-255.pbf', Buffer.from('')),
-    ]);
-
-    const fonts = await getFonts('memory://fonts/');
-    o(fonts).deepEquals(['Roboto Black', 'Roboto Thin']);
-  });
-
-  o('should return empty list if no fonts found', async () => {
-    const res = await fontList(mockRequest('/v1/fonts.json'));
-    o(res.status).equals(200);
-    o(res.body).equals('[]');
-    o(res.header('etag')).notEquals(undefined);
-    o(res.header('cache-control')).equals('public, max-age=604800, stale-while-revalidate=86400');
-  });
-
-  o('should return 404 if no assets defined', async () => {
-    delete process.env[Env.AssetLocation];
+  o('should return 404 if no font found', async () => {
     const res = await fontList(mockRequest('/v1/fonts.json'));
     o(res.status).equals(404);
   });
 
   o('should return a list of fonts found', async () => {
-    await Promise.all([
-      fsa.write('memory://fonts/Roboto Thin/0-255.pbf', Buffer.from('')),
-      fsa.write('memory://fonts/Roboto Thin/256-512.pbf', Buffer.from('')),
-      fsa.write('memory://fonts/Roboto Black/0-255.pbf', Buffer.from('')),
-    ]);
+    await fsa.write('memory://fonts.json', Buffer.from(JSON.stringify(['Roboto Black', 'Roboto Thin'])));
     const res = await fontList(mockRequest('/v1/fonts.json'));
     o(res.status).equals(200);
     o(res.header('content-type')).equals('application/json');
     o(res.header('content-encoding')).equals(undefined);
-    o(res.body).equals(JSON.stringify(['Roboto Black', 'Roboto Thin']));
+    o(res._body?.toString()).equals(JSON.stringify(['Roboto Black', 'Roboto Thin']));
   });
 
   o('should get the correct font', async () => {
@@ -83,4 +66,43 @@ o.spec('/v1/fonts', () => {
     o(res255.header('etag')).notEquals(undefined);
     o(res255.header('cache-control')).equals('public, max-age=604800, stale-while-revalidate=86400');
   });
+
+  o('should return 404 if no asset location set', async () => {
+    getDefaultConfig().assets = undefined;
+    const res = await fontList(mockRequest('/v1/fonts.json'));
+    o(res.status).equals(404);
+  });
+
+  o('should get the correct utf8 font with default assets', async () => {
+    const cfgBundle = new ConfigProviderMemory();
+    await fsa.write('memory://linz-basemaps/bar.json', JSON.stringify(cfgBundle.toJson()));
+    await fsa.write('memory://config/fonts/🦄 🌈/0-255.pbf', Buffer.from(''));
+
+    const configLocation = base58.encode(Buffer.from('memory://linz-basemaps/bar.json'));
+    const res255 = await handler.router.handle(
+      mockUrlRequest('/v1/fonts/🦄 🌈/0-255.pbf', `?config=${configLocation}`, Api.header),
+    );
+    o(res255.status).equals(200);
+    o(res255.header('content-type')).equals('application/x-protobuf');
+    o(res255.header('content-encoding')).equals(undefined);
+    o(res255.header('etag')).notEquals(undefined);
+    o(res255.header('cache-control')).equals('public, max-age=604800, stale-while-revalidate=86400');
+  });
+
+  o('should get the correct utf8 font with config assets', async () => {
+    const cfgBundle = new ConfigProviderMemory();
+    cfgBundle.assets = 'memory://config/assets';
+    await fsa.write('memory://linz-basemaps/bar.json', JSON.stringify(cfgBundle.toJson()));
+    await fsa.write('memory://config/assets/fonts/🦄 🌈/0-255.pbf', Buffer.from(''));
+
+    const configLocation = base58.encode(Buffer.from('memory://linz-basemaps/bar.json'));
+    const res255 = await handler.router.handle(
+      mockUrlRequest('/v1/fonts/🦄 🌈/0-255.pbf', `?config=${configLocation}`, Api.header),
+    );
+    o(res255.status).equals(200);
+    o(res255.header('content-type')).equals('application/x-protobuf');
+    o(res255.header('content-encoding')).equals(undefined);
+    o(res255.header('etag')).notEquals(undefined);
+    o(res255.header('cache-control')).equals('public, max-age=604800, stale-while-revalidate=86400');
+  });
 });

package/src/routes/__tests__/health.test.ts

@@ -1,9 +1,10 @@
-import { Config, ConfigProviderMemory } from '@basemaps/config';
+import { ConfigProviderMemory } from '@basemaps/config';
 import { LogConfig } from '@basemaps/shared';
 import { LambdaAlbRequest, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import { Context } from 'aws-lambda';
 import o from 'ospec';
 import sinon from 'sinon';
+import { ConfigLoader } from '../../util/config.loader.js';
 import { FakeData } from '../../__tests__/config.data.js';
 
 import { getTestBuffer, healthGet, TestTiles } from '../health.js';
@@ -29,11 +30,12 @@ o.spec('/v1/health', async () => {
   const fakeTileSet = FakeData.tileSetRaster('health');
   o.beforeEach(() => {
     config.objects.clear();
-    Config.setConfigProvider(config);
+    sandbox.stub(ConfigLoader, 'getDefaultConfig').resolves(config);
     config.put(fakeTileSet);
   });
 
   o.afterEach(() => {
+    config.objects.clear();
     sandbox.restore();
   });
 

package/src/routes/__tests__/sprites.test.ts

@@ -1,6 +1,7 @@
-import { Env } from '@basemaps/shared';
+import { Env, getDefaultConfig } from '@basemaps/shared';
 import { fsa } from '@chunkd/fs';
 import o from 'ospec';
+import { createSandbox } from 'sinon';
 import { gunzipSync, gzipSync } from 'zlib';
 import { handler } from '../../index.js';
 import { mockRequest } from '../../__tests__/xyz.util.js';
@@ -8,19 +9,22 @@ import { FsMemory } from './memory.fs.js';
 
 o.spec('/v1/sprites', () => {
   const memory = new FsMemory();
+  const sandbox = createSandbox();
   o.before(() => {
     fsa.register('memory://', memory);
   });
+  const assetLocation = process.env[Env.AssetLocation];
 
   o.beforeEach(() => {
     process.env[Env.AssetLocation] = 'memory://';
+    getDefaultConfig().assets = 'memory://';
   });
 
   o.afterEach(() => {
-    delete process.env[Env.AssetLocation];
+    getDefaultConfig().assets = assetLocation;
     memory.files.clear();
+    sandbox.restore();
   });
-
   o('should return 404 if no assets defined', async () => {
     delete process.env[Env.AssetLocation];
     const res404 = await handler.router.handle(mockRequest('/v1/sprites/topographic.json'));

package/src/routes/__tests__/tile.json.test.ts

@@ -1,23 +1,33 @@
-import { Config, ConfigProviderMemory } from '@basemaps/config';
+import { base58, ConfigProviderMemory } from '@basemaps/config';
 import { Env } from '@basemaps/shared';
+import { fsa } from '@chunkd/fs';
 import o from 'ospec';
+import sinon from 'sinon';
 import { handler } from '../../index.js';
+import { ConfigLoader } from '../../util/config.loader.js';
 import { CoSources } from '../../util/source.cache.js';
 import { FakeData } from '../../__tests__/config.data.js';
 import { Api, mockRequest, mockUrlRequest } from '../../__tests__/xyz.util.js';
+import { FsMemory } from './memory.fs.js';
 
 o.spec('/v1/tiles/:tileSet/:tileMatrix/tile.json', () => {
   const config = new ConfigProviderMemory();
+  const sandbox = sinon.createSandbox();
+
   o.before(() => {
     process.env[Env.PublicUrlBase] = 'https://tiles.test';
-    Config.setConfigProvider(config);
   });
 
   o.beforeEach(() => {
+    sandbox.stub(ConfigLoader, 'getDefaultConfig').resolves(config);
     config.objects.clear();
     CoSources.cache.clear();
   });
 
+  o.afterEach(() => {
+    sandbox.restore();
+  });
+
   o('should 404 if invalid url is given', async () => {
     const request = mockRequest('/v1/tiles/tile.json', 'get', Api.header);
 
@@ -123,6 +133,24 @@ o.spec('/v1/tiles/:tileSet/:tileMatrix/tile.json', () => {
     });
   });
 
+  o('should load from config bundle', async () => {
+    const memoryFs = new FsMemory();
+    fsa.register('memory://', memoryFs);
+    const fakeTileSet = FakeData.tileSetRaster('🦄 🌈');
+
+    const cfgBundle = new ConfigProviderMemory();
+    cfgBundle.put(fakeTileSet);
+    memoryFs.write('memory://linz-basemaps/bar.json', JSON.stringify(cfgBundle.toJson()));
+
+    const configLocation = base58.encode(Buffer.from('memory://linz-basemaps/bar.json'));
+    const request = mockUrlRequest('/v1/tiles/🦄 🌈/NZTM2000Quad/tile.json', `?config=${configLocation}`, Api.header);
+    const res = await handler.router.handle(request);
+    o(res.status).equals(200);
+
+    const body = JSON.parse(Buffer.from(res.body, 'base64').toString());
+    o(body.tiles[0].includes(`config=${configLocation}`)).equals(true);
+  });
+
   o('should serve convert zoom to tile matrix', async () => {
     const fakeTileSet = FakeData.tileSetVector('fake-vector');
     fakeTileSet.maxZoom = 15;

package/src/routes/__tests__/tile.style.json.test.ts

@@ -1,24 +1,29 @@
-import { Config, StyleJson } from '@basemaps/config';
+import { ConfigProviderMemory, StyleJson } from '@basemaps/config';
 import { Env } from '@basemaps/shared';
 import o from 'ospec';
 import { createSandbox } from 'sinon';
 import { handler } from '../../index.js';
-import { Api, mockRequest } from '../../__tests__/xyz.util.js';
+import { ConfigLoader } from '../../util/config.loader.js';
+import { FakeData } from '../../__tests__/config.data.js';
+import { Api, mockRequest, mockUrlRequest } from '../../__tests__/xyz.util.js';
 
 o.spec('/v1/styles', () => {
   const host = 'https://tiles.test';
+  const config = new ConfigProviderMemory();
   const sandbox = createSandbox();
 
   o.before(() => {
     process.env[Env.PublicUrlBase] = host;
   });
-  //   o.beforeEach(() => {});
-  o.afterEach(() => sandbox.restore());
+  o.beforeEach(() => {
+    sandbox.stub(ConfigLoader, 'getDefaultConfig').resolves(config);
+  });
+  o.afterEach(() => {
+    sandbox.restore();
+    config.objects.clear();
+  });
   o('should not found style json', async () => {
     const request = mockRequest('/v1/tiles/topographic/Google/style/topographic.json', 'get', Api.header);
-
-    sandbox.stub(Config.Style, 'get').resolves(null);
-
     const res = await handler.router.handle(request);
     o(res.status).equals(404);
   });
@@ -71,12 +76,12 @@ o.spec('/v1/styles', () => {
     };
 
     const fakeRecord = {
-      id: 'st_topographic_production',
+      id: 'st_topographic',
       name: 'topographic',
       style: fakeStyle,
     };
 
-    sandbox.stub(Config.Style, 'get').resolves(fakeRecord as any);
+    config.put(fakeRecord);
 
     const res = await handler.router.handle(request);
     o(res.status).equals(200);
@@ -102,4 +107,58 @@ o.spec('/v1/styles', () => {
 
     o(JSON.parse(body)).deepEquals(fakeStyle);
   });
+
+  o('should create raster styles', async () => {
+    const request = mockUrlRequest('/v1/styles/aerial.json', '', Api.header);
+    const tileSet = FakeData.tileSetRaster('aerial');
+    config.put(tileSet);
+    const res = await handler.router.handle(request);
+    o(res.status).equals(200);
+
+    const body = JSON.parse(Buffer.from(res.body, 'base64').toString());
+
+    o(body.version).equals(8);
+    o(body.sources['basemaps-aerial'].type).deepEquals('raster');
+    o(body.sources['basemaps-aerial'].tiles).deepEquals([
+      `https://tiles.test/v1/tiles/aerial/WebMercatorQuad/{z}/{x}/{y}.webp?api=${Api.key}`,
+    ]);
+    o(body.sources['basemaps-aerial'].tileSize).deepEquals(256);
+    o(body.layers).deepEquals([{ id: 'basemaps-aerial', type: 'raster', source: 'basemaps-aerial' }]);
+  });
+
+  o('should support parameters', async () => {
+    const request = mockUrlRequest('/v1/styles/aerial.json', '?tileMatrix=NZTM2000Quad&format=jpg', Api.header);
+    const tileSet = FakeData.tileSetRaster('aerial');
+    config.put(tileSet);
+    const res = await handler.router.handle(request);
+    o(res.status).equals(200);
+
+    const body = JSON.parse(Buffer.from(res.body, 'base64').toString());
+
+    o(body.version).equals(8);
+    o(body.sources['basemaps-aerial'].type).deepEquals('raster');
+    o(body.sources['basemaps-aerial'].tiles).deepEquals([
+      `https://tiles.test/v1/tiles/aerial/NZTM2000Quad/{z}/{x}/{y}.jpeg?api=${Api.key}`,
+    ]);
+    o(body.sources['basemaps-aerial'].tileSize).deepEquals(256);
+    o(body.layers).deepEquals([{ id: 'basemaps-aerial', type: 'raster', source: 'basemaps-aerial' }]);
+  });
+
+  o('should create raster styles from custom config', async () => {
+    const configId = FakeData.bundle([FakeData.tileSetRaster('aerial')]);
+    const request = mockUrlRequest('/v1/styles/aerial.json', `?config=${configId}`, Api.header);
+
+    const res = await handler.router.handle(request);
+    o(res.status).equals(200);
+
+    const body = JSON.parse(Buffer.from(res.body, 'base64').toString());
+
+    o(body.version).equals(8);
+    o(body.sources['basemaps-aerial'].type).deepEquals('raster');
+    o(body.sources['basemaps-aerial'].tiles).deepEquals([
+      `https://tiles.test/v1/tiles/aerial/WebMercatorQuad/{z}/{x}/{y}.webp?api=${Api.key}&config=${configId}`,
+    ]);
+    o(body.sources['basemaps-aerial'].tileSize).deepEquals(256);
+    o(body.layers).deepEquals([{ id: 'basemaps-aerial', type: 'raster', source: 'basemaps-aerial' }]);
+  });
 });

package/src/routes/__tests__/wmts.test.ts

@@ -1,13 +1,21 @@
-import { Config } from '@basemaps/shared';
+import { ConfigProviderMemory } from '@basemaps/config';
 import o from 'ospec';
 import { createSandbox } from 'sinon';
 import { handler } from '../../index.js';
+import { ConfigLoader } from '../../util/config.loader.js';
 import { Imagery2193, Imagery3857, Provider, TileSetAerial } from '../../__tests__/config.data.js';
 import { Api, mockUrlRequest } from '../../__tests__/xyz.util.js';
 
 o.spec('WMTSRouting', () => {
   const sandbox = createSandbox();
+  const config = new ConfigProviderMemory();
+
+  o.before(() => {
+    sandbox.stub(ConfigLoader, 'load').resolves(config);
+  });
+
   o.afterEach(() => {
+    config.objects.clear();
     sandbox.restore();
   });
 
@@ -16,25 +24,17 @@ o.spec('WMTSRouting', () => {
     imagery.set(Imagery3857.id, Imagery3857);
     imagery.set(Imagery2193.id, Imagery2193);
 
-    const tileSetStub = sandbox.stub(Config.TileSet, 'get').returns(Promise.resolve(TileSetAerial));
-    const imageryStub = sandbox.stub(Config.Imagery, 'getAll').returns(Promise.resolve(imagery));
-    const providerStub = sandbox.stub(Config.Provider, 'get').returns(Promise.resolve(Provider));
+    config.put(TileSetAerial);
+    config.put(Imagery2193);
+    config.put(Imagery3857);
+    config.put(Provider);
 
-    const req = mockUrlRequest('/v1/tiles/WMTSCapabilities.xml', `format=png&api=${Api.key}`);
+    const req = mockUrlRequest(
+      '/v1/tiles/WMTSCapabilities.xml',
+      `format=png&api=${Api.key}&config=s3://linz-basemaps/config.json`,
+    );
     const res = await handler.router.handle(req);
 
-    o(tileSetStub.calledOnce).equals(true);
-    o(tileSetStub.args[0][0]).equals('ts_aerial');
-
-    o(providerStub.calledOnce).equals(true);
-    o(providerStub.args[0][0]).equals('pv_linz');
-
-    o(imageryStub.calledOnce).equals(true);
-    o([...imageryStub.args[0][0].values()]).deepEquals([
-      'im_01FYWKATAEK2ZTJQ2PX44Y0XNT',
-      'im_01FYWKAJ86W9P7RWM1VB62KD0H',
-    ]);
-
     o(res.status).equals(200);
     const lines = Buffer.from(res.body, 'base64').toString().split('\n');
 
@@ -46,5 +46,11 @@ o.spec('WMTSRouting', () => {
       '<ows:Title>Google Maps Compatible for the World</ows:Title>',
       '<ows:Title>LINZ NZTM2000 Map Tile Grid V2</ows:Title>',
     ]);
+
+    const resourceURLs = lines.filter((f) => f.includes('<ResourceURL')).map((f) => f.trim());
+    o(resourceURLs).deepEquals([
+      '<ResourceURL format="image/png" resourceType="tile" template="https://tiles.test/v1/tiles/aerial/{TileMatrixSet}/{TileMatrix}/{TileCol}/{TileRow}.png?api=d01f7w7rnhdzg0p7fyrc9v9ard1&amp;config=Q5pC4UjWdtFLU1CYtLcRSmB49RekgDgMa5EGJnB2M" />',
+      '<ResourceURL format="image/png" resourceType="tile" template="https://tiles.test/v1/tiles/ōtorohanga-urban-2021-0.1m/{TileMatrixSet}/{TileMatrix}/{TileCol}/{TileRow}.png?api=d01f7w7rnhdzg0p7fyrc9v9ard1&amp;config=Q5pC4UjWdtFLU1CYtLcRSmB49RekgDgMa5EGJnB2M" />',
+    ]);
   });
 });

package/src/routes/__tests__/xyz.test.ts

@@ -1,9 +1,10 @@
-import { Config, ConfigProviderMemory } from '@basemaps/config';
+import { ConfigProviderMemory } from '@basemaps/config';
 import { LogConfig } from '@basemaps/shared';
 import { round } from '@basemaps/test/build/rounding.js';
 import o from 'ospec';
 import sinon from 'sinon';
 import { handler } from '../../index.js';
+import { ConfigLoader } from '../../util/config.loader.js';
 import { Etag } from '../../util/etag.js';
 import { FakeData } from '../../__tests__/config.data.js';
 import { Api, mockRequest } from '../../__tests__/xyz.util.js';
@@ -16,7 +17,7 @@ o.spec('/v1/tiles', () => {
 
   o.beforeEach(() => {
     LogConfig.get().level = 'silent';
-    Config.setConfigProvider(config);
+    sandbox.stub(ConfigLoader, 'getDefaultConfig').resolves(config);
     config.objects.clear();
 
     for (const tileSetName of TileSetNames) config.put(FakeData.tileSetRaster(tileSetName));
@@ -25,6 +26,7 @@ o.spec('/v1/tiles', () => {
   });
 
   o.afterEach(() => {
+    config.objects.clear();
     sandbox.restore();
   });