@basemaps/lambda-tiler 6.34.0 → 6.35.0

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/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);

package/src/routes/tile.json.ts

@@ -1,6 +1,7 @@
 import { GoogleTms, TileJson, TileMatrixSet } from '@basemaps/geo';
-import { Config, Env } from '@basemaps/shared';
+import { Env, toQueryString } from '@basemaps/shared';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import { ConfigLoader } from '../util/config.loader.js';
 import { NotFound } from '../util/response.js';
 import { Validate } from '../util/validate.js';
 
@@ -17,8 +18,10 @@ export async function tileJsonGet(req: LambdaHttpRequest<TileJsonGet>): Promise<
 
   const apiKey = Validate.apiKey(req);
 
+  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) return NotFound();
 
@@ -26,9 +29,12 @@ export async function tileJsonGet(req: LambdaHttpRequest<TileJsonGet>): Promise<
 
   const host = Env.get(Env.PublicUrlBase) ?? '';
 
+  const configLocation = ConfigLoader.extract(req);
+
+  const query = toQueryString({ api: apiKey, config: configLocation });
+
   const tileUrl =
-    [host, 'v1', 'tiles', tileSet.name, tileMatrix.identifier, '{z}', '{x}', '{y}'].join('/') +
-    `.${format[0]}?api=${apiKey}`;
+    [host, 'v1', 'tiles', tileSet.name, tileMatrix.identifier, '{z}', '{x}', '{y}'].join('/') + `.${format[0]}${query}`;
 
   const tileJson: TileJson = { tiles: [tileUrl], tilejson: '3.0.0' };
   const maxZoom = TileMatrixSet.convertZoomLevel(tileSet.maxZoom ?? 30, GoogleTms, tileMatrix, true);

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

@@ -1,11 +1,13 @@
-import { Sources, StyleJson } from '@basemaps/config';
-import { Config, Env } from '@basemaps/shared';
+import { ConfigTileSetRaster, Sources, StyleJson, TileSetType } from '@basemaps/config';
+import { Env, toQueryString } from '@basemaps/shared';
 import { fsa } from '@chunkd/fs';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import { URL } from 'url';
 import { NotFound, NotModified } from '../util/response.js';
 import { Validate } from '../util/validate.js';
 import { Etag } from '../util/etag.js';
+import { ConfigLoader } from '../util/config.loader.js';
+import { GoogleTms, ImageFormat, TileMatrixSets } from '@basemaps/geo';
 
 /**
  * Convert relative URLS into a full hostname url
@@ -13,12 +15,13 @@ import { Etag } from '../util/etag.js';
  * @param apiKey ApiKey to append with ?api= if required
  * @returns Updated Url or empty string if url is empty
  */
-export function convertRelativeUrl(url?: string, apiKey?: string): string {
+export function convertRelativeUrl(url?: string, apiKey?: string, config?: string | null): string {
   if (url == null) return '';
   const host = Env.get(Env.PublicUrlBase) ?? '';
   if (!url.startsWith('/')) return url; // Not relative ignore
   const fullUrl = new URL(fsa.join(host, url));
   if (apiKey) fullUrl.searchParams.set('api', apiKey);
+  if (config) fullUrl.searchParams.set('config', config);
   return fullUrl.toString().replace(/%7B/g, '{').replace(/%7D/g, '}');
 }
 
@@ -28,14 +31,14 @@ export function convertRelativeUrl(url?: string, apiKey?: string): string {
  * @param apiKey api key to inject
  * @returns new stylejson
  */
-export function convertStyleJson(style: StyleJson, apiKey: string): StyleJson {
+export function convertStyleJson(style: StyleJson, apiKey: string, config: string | null): StyleJson {
   const sources: Sources = JSON.parse(JSON.stringify(style.sources));
   for (const [key, value] of Object.entries(sources)) {
     if (value.type === 'vector') {
-      value.url = convertRelativeUrl(value.url, apiKey);
+      value.url = convertRelativeUrl(value.url, apiKey, config);
     } else if (value.type === 'raster' && Array.isArray(value.tiles)) {
       for (let i = 0; i < value.tiles.length; i++) {
-        value.tiles[i] = convertRelativeUrl(value.tiles[i], apiKey);
+        value.tiles[i] = convertRelativeUrl(value.tiles[i], apiKey, config);
       }
     }
     sources[key] = value;
@@ -48,8 +51,8 @@ export function convertStyleJson(style: StyleJson, apiKey: string): StyleJson {
     sources,
     layers: style.layers,
     metadata: style.metadata ?? {},
-    glyphs: convertRelativeUrl(style.glyphs),
-    sprite: convertRelativeUrl(style.sprite),
+    glyphs: convertRelativeUrl(style.glyphs, undefined, config),
+    sprite: convertRelativeUrl(style.sprite, undefined, config),
   } as StyleJson;
 }
 
@@ -59,17 +62,60 @@ export interface StyleGet {
   };
 }
 
+export async function tileSetToStyle(
+  req: LambdaHttpRequest<StyleGet>,
+  tileSet: ConfigTileSetRaster,
+  apiKey: string,
+): Promise<LambdaHttpResponse> {
+  const tileMatrix = TileMatrixSets.find(req.query.get('tileMatrix') ?? GoogleTms.identifier);
+  if (tileMatrix == null) return new LambdaHttpResponse(400, 'Invalid tile matrix');
+  const [tileFormat] = Validate.getRequestedFormats(req) ?? [ImageFormat.Webp];
+  if (tileFormat == null) return new LambdaHttpResponse(400, 'Invalid image format');
+
+  const configLocation = ConfigLoader.extract(req);
+  const query = toQueryString({ config: configLocation, api: apiKey });
+
+  const tileUrl = fsa.join(
+    Env.get(Env.PublicUrlBase) ?? '',
+    `/v1/tiles/${tileSet.name}/${tileMatrix.identifier}/{z}/{x}/{y}.${tileFormat}${query}`,
+  );
+  const styleId = `basemaps-${tileSet.name}`;
+  const style = {
+    version: 8,
+    sources: { [styleId]: { type: 'raster', tiles: [tileUrl], tileSize: 256 } },
+    layers: [{ id: styleId, type: 'raster', source: styleId }],
+  };
+  const data = Buffer.from(JSON.stringify(style));
+
+  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;
+}
+
 export async function styleJsonGet(req: LambdaHttpRequest<StyleGet>): Promise<LambdaHttpResponse> {
   const apiKey = Validate.apiKey(req);
   const styleName = req.params.styleName;
 
   // Get style Config from db
-  const dbId = Config.Style.id(styleName);
-  const styleConfig = await Config.Style.get(dbId);
-  if (styleConfig == null) return NotFound();
+  const config = await ConfigLoader.load(req);
+  const dbId = config.Style.id(styleName);
+  const styleConfig = await config.Style.get(dbId);
+  if (styleConfig == null) {
+    // Were we given a tileset name instead, generated
+    const tileSet = await config.TileSet.get(config.TileSet.id(styleName));
+    if (tileSet == null) return NotFound();
+    if (tileSet.type !== TileSetType.Raster) return NotFound();
+    return tileSetToStyle(req, tileSet, apiKey);
+  }
 
   // Prepare sources and add linz source
-  const style = convertStyleJson(styleConfig.style, apiKey);
+  const style = convertStyleJson(styleConfig.style, apiKey, ConfigLoader.extract(req));
   const data = Buffer.from(JSON.stringify(style));
 
   const cacheKey = Etag.key(data);

package/src/routes/tile.wmts.ts

@@ -1,4 +1,4 @@
-import { Config, TileSetType } from '@basemaps/config';
+import { getAllImagery, TileSetType } from '@basemaps/config';
 import { GoogleTms, Nztm2000QuadTms, TileMatrixSet } from '@basemaps/geo';
 import { Env } from '@basemaps/shared';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
@@ -7,6 +7,7 @@ import { NotFound, NotModified } from '../util/response.js';
 import { Validate } from '../util/validate.js';
 import { WmtsCapabilities } from '../wmts.capability.js';
 import { Etag } from '../util/etag.js';
+import { ConfigLoader } from '../util/config.loader.js';
 
 export interface WmtsCapabilitiesGet {
   Params: {
@@ -36,15 +37,18 @@ export async function wmtsCapabilitiesGet(req: LambdaHttpRequest<WmtsCapabilitie
 
   const host = Env.get(Env.PublicUrlBase) ?? '';
 
+  const config = await ConfigLoader.load(req);
+
   req.timer.start('tileset:load');
-  const tileSet = await Config.TileSet.get(Config.TileSet.id(tileSetName ?? 'aerial'));
+  const tileSet = await config.TileSet.get(config.TileSet.id(tileSetName ?? 'aerial'));
   req.timer.end('tileset:load');
   if (tileSet == null || tileSet.type !== TileSetType.Raster) return NotFound();
 
-  const provider = await Config.Provider.get(Config.Provider.id('linz'));
+  const provider = await config.Provider.get(config.Provider.id('linz'));
 
   req.timer.start('imagery:load');
-  const imagery = await Config.getAllImagery(
+  const imagery = await getAllImagery(
+    config,
     tileSet.layers,
     tileMatrix.map((tms) => tms.projection),
   );
@@ -58,6 +62,7 @@ export async function wmtsCapabilitiesGet(req: LambdaHttpRequest<WmtsCapabilitie
     isIndividualLayers: req.params.tileMatrix == null,
     imagery,
     apiKey,
+    config: ConfigLoader.extract(req),
     formats: Validate.getRequestedFormats(req),
   }).toXml();
   if (xml == null) return NotFound();

package/src/routes/tile.xyz.raster.ts

@@ -1,4 +1,4 @@
-import { Config, ConfigTileSetRaster } from '@basemaps/config';
+import { getAllImagery, ConfigTileSetRaster } from '@basemaps/config';
 import { Bounds, Epsg, TileMatrixSet, TileMatrixSets, VectorFormat } from '@basemaps/geo';
 import { Env, fsa } from '@basemaps/shared';
 import { Tiler } from '@basemaps/tiler';
@@ -6,6 +6,7 @@ import { TileMakerSharp } from '@basemaps/tiler-sharp';
 import { CogTiff } from '@cogeotiff/core';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import pLimit from 'p-limit';
+import { ConfigLoader } from '../util/config.loader.js';
 import { Etag } from '../util/etag.js';
 import { NotFound, NotModified } from '../util/response.js';
 import { CoSources } from '../util/source.cache.js';
@@ -26,7 +27,8 @@ const DefaultBackground = { r: 0, g: 0, b: 0, alpha: 0 };
 
 export const TileXyzRaster = {
   async getTiffsForTile(req: LambdaHttpRequest, tileSet: ConfigTileSetRaster, xyz: TileXyz): Promise<string[]> {
-    const imagery = await Config.getAllImagery(tileSet.layers, [xyz.tileMatrix.projection]);
+    const config = await ConfigLoader.load(req);
+    const imagery = await getAllImagery(config, tileSet.layers, [xyz.tileMatrix.projection]);
 
     const output: string[] = [];
     const tileBounds = xyz.tileMatrix.tileToSourceBounds(xyz.tile);

package/src/routes/tile.xyz.ts

@@ -1,5 +1,6 @@
-import { Config, TileSetType } from '@basemaps/config';
+import { TileSetType } from '@basemaps/config';
 import { LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import { ConfigLoader } from '../util/config.loader.js';
 import { NotFound } from '../util/response.js';
 import { Validate } from '../util/validate.js';
 import { TileXyzRaster } from './tile.xyz.raster.js';
@@ -29,8 +30,10 @@ export interface TileXyzGet {
 export async function tileXyzGet(req: LambdaHttpRequest<TileXyzGet>): Promise<LambdaHttpResponse> {
   const xyzData = Validate.xyz(req);
 
+  const config = await ConfigLoader.load(req);
+
   req.timer.start('tileset:load');
-  const tileSet = await Config.TileSet.get(Config.TileSet.id(xyzData.tileSet));
+  const tileSet = await config.TileSet.get(config.TileSet.id(xyzData.tileSet));
   req.timer.end('tileset:load');
   if (tileSet == null) return NotFound();