@basemaps/lambda-tiler 6.33.0 → 6.35.0

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

@@ -1,76 +1,16 @@
-import { Env } from '@basemaps/shared';
-import { fsa } from '@chunkd/fs';
-import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import { LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import path from 'path';
-import { isGzip, serveFromCotar } from '../util/cotar.serve.js';
-import { Etag } from '../util/etag.js';
-import { NotFound, NotModified } from '../util/response.js';
+import { assetProvider } from '../util/assets.provider.js';
 
 interface FontGet {
   Params: { fontStack: string; range: string };
 }
 
 export async function fontGet(req: LambdaHttpRequest<FontGet>): Promise<LambdaHttpResponse> {
-  const assetLocation = Env.get(Env.AssetLocation);
-  if (assetLocation == null) return NotFound();
-
   const targetFile = path.join('fonts', req.params.fontStack, req.params.range) + '.pbf';
-  if (assetLocation.endsWith('.tar.co')) {
-    return serveFromCotar(req, assetLocation, targetFile, 'application/x-protobuf');
-  }
-
-  try {
-    const filePath = fsa.join(assetLocation, targetFile);
-    const buf = await fsa.read(filePath);
-
-    const cacheKey = Etag.key(buf);
-    if (Etag.isNotModified(req, cacheKey)) return NotModified();
-
-    const response = LambdaHttpResponse.ok().buffer(buf, 'application/x-protobuf');
-    response.header(HttpHeader.ETag, cacheKey);
-    response.header(HttpHeader.CacheControl, 'public, max-age=604800, stale-while-revalidate=86400');
-    if (isGzip(buf)) response.header(HttpHeader.ContentEncoding, 'gzip');
-    return response;
-  } catch (e: any) {
-    if (e.code === 404) return NotFound();
-    throw e;
-  }
-}
-
-/** Get the unique name of folders is a path that contain .pbf files */
-export async function getFonts(fontPath: string): Promise<string[]> {
-  const fonts = new Set<string>();
-
-  // TODO use {recursive: false}
-  for await (const font of fsa.list(fontPath)) {
-    if (!font.endsWith('.pbf')) continue;
-    const dirName = path.basename(path.dirname(font)); // TODO this only works for /a/b.pbf and not /a/b/c.pbf
-    if (dirName.includes('/')) continue;
-    fonts.add(dirName);
-  }
-  // Ensure the fonts are alphabetical
-  return [...fonts].sort();
+  return assetProvider.serve(req, targetFile, 'application/x-protobuf');
 }
 
 export async function fontList(req: LambdaHttpRequest): Promise<LambdaHttpResponse> {
-  const assetLocation = Env.get(Env.AssetLocation);
-  if (assetLocation == null) return NotFound();
-
-  if (assetLocation.endsWith('.tar.co')) return serveFromCotar(req, assetLocation, 'fonts.json', 'application/json');
-
-  try {
-    const filePath = fsa.join(assetLocation, '/fonts');
-    const fonts = await getFonts(filePath);
-
-    const cacheKey = Etag.key(fonts);
-    if (Etag.isNotModified(req, cacheKey)) return NotModified();
-
-    const response = LambdaHttpResponse.ok().buffer(JSON.stringify(fonts), 'application/json');
-    response.header(HttpHeader.ETag, cacheKey);
-    response.header(HttpHeader.CacheControl, 'public, max-age=604800, stale-while-revalidate=86400');
-    return response;
-  } catch (e: any) {
-    if (e.code === 404) return NotFound();
-    throw e;
-  }
+  return assetProvider.serve(req, '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);

package/src/routes/sprites.ts

@@ -1,10 +1,8 @@
-import { Env } from '@basemaps/shared';
 import { fsa } from '@chunkd/fs';
 import path from 'path';
-import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
-import { NotFound, NotModified } from '../util/response.js';
-import { isGzip, serveFromCotar } from '../util/cotar.serve.js';
-import { Etag } from '../util/etag.js';
+import { LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import { NotFound } from '../util/response.js';
+import { assetProvider } from '../util/assets.provider.js';
 
 interface SpriteGet {
   Params: {
@@ -17,31 +15,10 @@ Extensions.set('.png', 'image/png');
 Extensions.set('.json', 'application/json');
 
 export async function spriteGet(req: LambdaHttpRequest<SpriteGet>): Promise<LambdaHttpResponse> {
-  const assetLocation = Env.get(Env.AssetLocation);
-  if (assetLocation == null) return NotFound();
-
   const extension = path.extname(req.params.spriteName);
   const mimeType = Extensions.get(extension);
   if (mimeType == null) return NotFound();
 
   const targetFile = fsa.join('sprites', req.params.spriteName);
-  if (assetLocation.endsWith('.tar.co')) return serveFromCotar(req, assetLocation, targetFile, mimeType);
-
-  try {
-    const filePath = fsa.join(assetLocation, targetFile);
-    req.set('target', filePath);
-
-    const buf = await fsa.read(filePath);
-    const cacheKey = Etag.key(buf);
-    if (Etag.isNotModified(req, cacheKey)) return NotModified();
-
-    const response = LambdaHttpResponse.ok().buffer(buf, mimeType);
-    response.header(HttpHeader.ETag, cacheKey);
-    response.header(HttpHeader.CacheControl, 'public, max-age=604800, stale-while-revalidate=86400');
-    if (isGzip(buf)) response.header(HttpHeader.ContentEncoding, 'gzip');
-    return response;
-  } catch (e: any) {
-    if (e.code === 404) return NotFound();
-    throw e;
-  }
+  return assetProvider.serve(req, targetFile, mimeType);
 }

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