@basemaps/lambda-tiler 6.34.0 → 6.36.0

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

@@ -1,26 +1,34 @@
-import { Env } from '@basemaps/shared';
+import { base58, ConfigProviderMemory } from '@basemaps/config';
+import { getDefaultConfig } from '@basemaps/shared';
 import { fsa } from '@chunkd/fs';
 import o from 'ospec';
+import { createSandbox } from 'sinon';
 import { handler } from '../../index.js';
-import { assetProvider } from '../../util/assets.provider.js';
-import { mockRequest } from '../../__tests__/xyz.util.js';
+import { CachedConfig } from '../../util/config.cache.js';
+import { ConfigLoader } from '../../util/config.loader.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', () => {
   const memory = new FsMemory();
+  const sandbox = createSandbox();
+  const config = new ConfigProviderMemory();
+
   o.before(() => {
     fsa.register('memory://', memory);
   });
-  const assetLocation = process.env[Env.AssetLocation];
 
   o.beforeEach(() => {
-    process.env[Env.AssetLocation] = 'memory://';
-    assetProvider.set('memory://');
+    config.assets = 'memory://';
+    sandbox.stub(ConfigLoader, 'getDefaultConfig').resolves(config);
   });
 
   o.afterEach(() => {
-    assetProvider.set(assetLocation);
+    sandbox.restore();
+    CachedConfig.cache.clear();
+    CoSources.cache.clear();
     memory.files.clear();
   });
 
@@ -30,7 +38,7 @@ o.spec('/v1/fonts', () => {
   });
 
   o('should return a list of fonts found', async () => {
-    await fsa.write('memory://fonts.json', Buffer.from(JSON.stringify(['Roboto Black', 'Roboto Thin'])));
+    await fsa.write('memory://fonts/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');
@@ -40,7 +48,6 @@ o.spec('/v1/fonts', () => {
 
   o('should get the correct font', async () => {
     await fsa.write('memory://fonts/Roboto Thin/0-255.pbf', Buffer.from(''));
-
     const res255 = await handler.router.handle(mockRequest('/v1/fonts/Roboto Thin/0-255.pbf'));
     o(res255.status).equals(200);
     o(res255.header('content-type')).equals('application/x-protobuf');
@@ -54,7 +61,6 @@ o.spec('/v1/fonts', () => {
 
   o('should get the correct utf8 font', async () => {
     await fsa.write('memory://fonts/🦄 🌈/0-255.pbf', Buffer.from(''));
-
     const res255 = await handler.router.handle(mockRequest('/v1/fonts/🦄 🌈/0-255.pbf'));
     o(res255.status).equals(200);
     o(res255.header('content-type')).equals('application/x-protobuf');
@@ -64,8 +70,39 @@ o.spec('/v1/fonts', () => {
   });
 
   o('should return 404 if no asset location set', async () => {
-    assetProvider.set(undefined);
+    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 () => {
+    getDefaultConfig().assets = undefined;
+    sandbox
+      .stub(config.ConfigBundle, 'get')
+      .resolves({ id: 'cb_latest', name: 'latest', path: 'latest', hash: 'hash', assets: 'memory://' });
+    await fsa.write('memory://fonts/Roboto Thin/0-255.pbf', Buffer.from(''));
+    const res255 = await handler.router.handle(mockRequest('/v1/fonts/Roboto Thin/0-255.pbf'));
+    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,36 +1,31 @@
-import { Env } from '@basemaps/shared';
+import { ConfigProviderMemory } from '@basemaps/config';
 import { fsa } from '@chunkd/fs';
 import o from 'ospec';
 import { createSandbox } from 'sinon';
 import { gunzipSync, gzipSync } from 'zlib';
 import { handler } from '../../index.js';
-import { assetProvider } from '../../util/assets.provider.js';
+import { ConfigLoader } from '../../util/config.loader.js';
 import { mockRequest } from '../../__tests__/xyz.util.js';
 import { FsMemory } from './memory.fs.js';
 
 o.spec('/v1/sprites', () => {
   const memory = new FsMemory();
   const sandbox = createSandbox();
+  const config = new ConfigProviderMemory();
+
   o.before(() => {
     fsa.register('memory://', memory);
   });
-  const assetLocation = process.env[Env.AssetLocation];
 
   o.beforeEach(() => {
-    process.env[Env.AssetLocation] = 'memory://';
-    assetProvider.set('memory://');
+    config.assets = 'memory://';
+    sandbox.stub(ConfigLoader, 'getDefaultConfig').resolves(config);
   });
 
   o.afterEach(() => {
-    assetProvider.set(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'));
-    o(res404.status).equals(404);
-  });
 
   o('should fetch a json document', async () => {
     await Promise.all([

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();
   });
 

package/src/routes/attribution.ts

@@ -1,4 +1,4 @@
-import { ConfigTileSet, TileSetType } from '@basemaps/config';
+import { ConfigProvider, ConfigTileSet, getAllImagery, TileSetType } from '@basemaps/config';
 import {
   AttributionCollection,
   AttributionItem,
@@ -8,11 +8,13 @@ import {
   NamedBounds,
   Stac,
   StacExtent,
+  StacProvider,
   TileMatrixSet,
 } from '@basemaps/geo';
-import { Config, extractYearRangeFromName, Projection, titleizeImageryName } from '@basemaps/shared';
+import { extractYearRangeFromName, Projection, titleizeImageryName } from '@basemaps/shared';
 import { BBox, MultiPolygon, multiPolygonToWgs84, Pair, union, Wgs84 } from '@linzjs/geojson';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import { ConfigLoader } from '../util/config.loader.js';
 
 import { Etag } from '../util/etag.js';
 import { NotFound, NotModified } from '../util/response.js';
@@ -62,6 +64,11 @@ function createCoordinates(bbox: BBox, files: NamedBounds[], proj: Projection):
   return multiPolygonToWgs84(coordinates, roundToWgs84);
 }
 
+function getHost(host: ConfigProvider | null): StacProvider[] | undefined {
+  if (host == null) return undefined;
+  return [{ name: host.serviceProvider.name, url: host.serviceProvider.site, roles: ['host'] }];
+}
+
 /**
  * Build a Single File STAC for the given TileSet.
  *
@@ -77,10 +84,10 @@ async function tileSetAttribution(
   const cols: AttributionCollection[] = [];
   const items: AttributionItem[] = [];
 
-  const imagery = await Config.getAllImagery(tileSet.layers, [tileMatrix.projection]);
+  const config = await ConfigLoader.load(req);
+  const imagery = await getAllImagery(config, tileSet.layers, [tileMatrix.projection]);
 
-  const host = await Config.Provider.get(Config.Provider.id('linz'));
-  if (host == null) return null;
+  const host = await config.Provider.get(config.Provider.id('linz'));
 
   for (const layer of tileSet.layers) {
     const imgId = layer[proj.epsg.code];
@@ -91,7 +98,13 @@ async function tileSetAttribution(
     const bbox = proj.boundsToWgs84BoundingBox(im.bounds).map(roundNumber) as BBox;
 
     const years = extractYearRangeFromName(im.name);
-    if (years[0] === -1) throw new Error('Missing date in imagery name: ' + im.name);
+    if (years[0] === -1) {
+      req.log.debug({ imagery: im.name }, 'Attribution:DefaultYear');
+      // Put it in the future so people know its a "fake" date
+      years[0] = new Date().getUTCFullYear() + 1;
+      years[1] = years[0] + 1;
+    }
+
     const interval = [years.map((y) => `${y}-01-01T00:00:00Z`) as [string, string]];
 
     const extent: StacExtent = { spatial: { bbox: [bbox] }, temporal: { interval } };
@@ -120,7 +133,7 @@ async function tileSetAttribution(
       stac_version: Stac.Version,
       license: Stac.License,
       id: im.id,
-      providers: [{ name: host.serviceProvider.name, url: host.serviceProvider.site, roles: ['host'] }],
+      providers: getHost(host),
       title: im.title ?? titleizeImageryName(im.name),
       description: 'No description',
       extent,
@@ -159,8 +172,10 @@ export async function tileAttributionGet(req: LambdaHttpRequest<TileAttributionG
   const tileMatrix = Validate.getTileMatrixSet(req.params.tileMatrix);
   if (tileMatrix == null) throw new LambdaHttpResponse(404, 'Tile Matrix not found');
 
+  const config = await ConfigLoader.load(req);
+
   req.timer.start('tileset:load');
-  const tileSet = await Config.TileSet.get(Config.TileSet.id(req.params.tileSet));
+  const tileSet = await config.TileSet.get(config.TileSet.id(req.params.tileSet));
   req.timer.end('tileset:load');
   if (tileSet == null || tileSet.type === TileSetType.Vector) return NotFound();
 

package/src/routes/config.ts

@@ -0,0 +1,83 @@
+import { standardizeLayerName } from '@basemaps/config';
+import { GoogleTms, TileMatrixSets } from '@basemaps/geo';
+import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import { ConfigLoader } from '../util/config.loader.js';
+import { Etag } from '../util/etag.js';
+import { NotFound, NotModified } from '../util/response.js';
+
+async function sendJson(req: LambdaHttpRequest, toSend: unknown): Promise<LambdaHttpResponse> {
+  const data = Buffer.from(JSON.stringify(toSend));
+
+  const cacheKey = Etag.key(data);
+  if (Etag.isNotModified(req, cacheKey)) return NotModified();
+
+  const response = new LambdaHttpResponse(200, 'ok');
+  response.header(HttpHeader.ETag, cacheKey);
+  response.header(HttpHeader.CacheControl, 'no-store');
+  response.buffer(data, 'application/json');
+  req.set('bytes', data.byteLength);
+  return response;
+}
+
+interface ConfigTileSetGet {
+  Params: {
+    tileSet: string;
+  };
+}
+
+export async function configTileSetGet(req: LambdaHttpRequest<ConfigTileSetGet>): Promise<LambdaHttpResponse> {
+  const config = await ConfigLoader.load(req);
+
+  req.timer.start('tileset:load');
+  const tileSet = await config.TileSet.get(config.TileSet.id(req.params.tileSet));
+  req.timer.end('tileset:load');
+  if (tileSet == null) return NotFound();
+
+  return sendJson(req, tileSet);
+}
+
+interface ConfigImageryGet {
+  Params: {
+    tileSet: string;
+    imageryId: string;
+  };
+}
+
+/**
+ * Load the imagery configuration by either name or id
+ *
+ * @param req
+ * @returns
+ */
+export async function configImageryGet(req: LambdaHttpRequest<ConfigImageryGet>): Promise<LambdaHttpResponse> {
+  const config = await ConfigLoader.load(req);
+
+  req.timer.start('tileset:load');
+  const tileSet = await config.TileSet.get(config.TileSet.id(req.params.tileSet));
+  req.timer.end('tileset:load');
+  if (tileSet == null) return NotFound();
+
+  req.timer.start('imagery:load');
+  let imagery = await config.Imagery.get(config.Imagery.id(req.params.imageryId));
+  req.timer.end('imagery:load');
+
+  if (imagery == null) {
+    const imageryLayer = tileSet.layers.find(
+      (f) => f.name === req.params.imageryId || standardizeLayerName(f.name) === req.params.imageryId,
+    );
+    if (imageryLayer == null) return NotFound();
+
+    const tileMatrix = TileMatrixSets.find(req.query.get('tileMatrix') ?? GoogleTms.identifier);
+    if (tileMatrix == null) return NotFound();
+
+    const imageryId = imageryLayer[tileMatrix.projection.code];
+    if (imageryId == null) return NotFound();
+
+    req.timer.start('imagery:load:sub');
+    imagery = await config.Imagery.get(config.Imagery.id(imageryId));
+    req.timer.end('imagery:load:sub');
+  }
+
+  if (imagery == null) return NotFound();
+  return sendJson(req, imagery);
+}

package/src/routes/fonts.ts

@@ -12,5 +12,5 @@ export async function fontGet(req: LambdaHttpRequest<FontGet>): Promise<LambdaHt
 }
 
 export async function fontList(req: LambdaHttpRequest): Promise<LambdaHttpResponse> {
-  return assetProvider.serve(req, 'fonts.json', 'application/json');
+  return assetProvider.serve(req, path.join('fonts', 'fonts.json'), 'application/json');
 }

package/src/routes/health.ts

@@ -1,4 +1,4 @@
-import { Config, ConfigTileSetRaster } from '@basemaps/config';
+import { ConfigTileSetRaster } from '@basemaps/config';
 import { GoogleTms, ImageFormat, Nztm2000QuadTms } from '@basemaps/geo';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import * as fs from 'fs';
@@ -6,6 +6,7 @@ import * as path from 'path';
 import PixelMatch from 'pixelmatch';
 import Sharp from 'sharp';
 import url from 'url';
+import { ConfigLoader } from '../util/config.loader.js';
 import { TileXyz } from '../util/validate.js';
 import { TileXyzRaster } from './tile.xyz.raster.js';
 
@@ -53,7 +54,8 @@ export async function updateExpectedTile(test: TestTile, newTileData: Buffer, di
  * @throws LambdaHttpResponse for failure health test
  */
 export async function healthGet(req: LambdaHttpRequest): Promise<LambdaHttpResponse> {
-  const tileSet = await Config.TileSet.get(Config.TileSet.id('health'));
+  const config = await ConfigLoader.load(req);
+  const tileSet = await config.TileSet.get(config.TileSet.id('health'));
   if (tileSet == null) throw new LambdaHttpResponse(500, 'TileSet: "health" not found');
   for (const test of TestTiles) {
     // Get the parse response tile to raw buffer

package/src/routes/imagery.ts

@@ -1,8 +1,8 @@
-import { Config } from '@basemaps/config';
 import { fsa } from '@basemaps/shared';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import { promisify } from 'util';
 import { gzip } from 'zlib';
+import { ConfigLoader } from '../util/config.loader.js';
 import { isGzip } from '../util/cotar.serve.js';
 import { Etag } from '../util/etag.js';
 import { NotFound, NotModified } from '../util/response.js';
@@ -34,7 +34,8 @@ export async function imageryGet(req: LambdaHttpRequest<ImageryGet>): Promise<La
   const requestedFile = req.params.fileName;
   if (!isAllowedFile(requestedFile)) return NotFound();
 
-  const imagery = await Config.Imagery.get(Config.Imagery.id(req.params.imageryId));
+  const config = await ConfigLoader.load(req);
+  const imagery = await config.Imagery.get(config.Imagery.id(req.params.imageryId));
   if (imagery == null) return NotFound();
 
   const targetPath = fsa.join(imagery.uri, requestedFile);