@basemaps/lambda-tiler 6.34.0 → 6.36.0

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

package/src/util/__test__/config.loader.test.ts

@@ -0,0 +1,116 @@
+import { base58, ConfigProviderMemory } from '@basemaps/config';
+import { fsa } from '@basemaps/shared';
+import { LambdaHttpResponse } from '@linzjs/lambda';
+import o from 'ospec';
+import { createSandbox } from 'sinon';
+import { FsMemory } from '../../routes/__tests__/memory.fs.js';
+import { FakeData } from '../../__tests__/config.data.js';
+import { Api, mockRequest, mockUrlRequest } from '../../__tests__/xyz.util.js';
+import { CachedConfig } from '../config.cache.js';
+import { ConfigLoader } from '../config.loader.js';
+
+o.spec('ConfigLoader', () => {
+  const memory = new FsMemory();
+  const config = new ConfigProviderMemory();
+  const sandbox = createSandbox();
+
+  o.before(() => {
+    fsa.register('memory://', memory);
+  });
+
+  o.beforeEach(() => {
+    sandbox.stub(ConfigLoader, 'getDefaultConfig').resolves(config);
+  });
+
+  o.afterEach(() => {
+    sandbox.restore();
+    config.objects.clear();
+    memory.files.clear();
+    CachedConfig.cache.clear();
+  });
+
+  o('should return default config', async () => {
+    const provider = await ConfigLoader.load(mockRequest('/v1/fonts.json'));
+    o(provider).deepEquals(config);
+  });
+
+  o('should Not working with wrong config url', async () => {
+    const error = await ConfigLoader.load(
+      mockUrlRequest('/v1/tiles/🦄 🌈/NZTM2000Quad/tile.json', `?config=notapath`, Api.header),
+    )
+      .then(() => null)
+      .catch((e) => e);
+
+    o(error instanceof LambdaHttpResponse).equals(true);
+    o((error as LambdaHttpResponse).status).equals(400);
+    o((error as LambdaHttpResponse).statusDescription).equals('Invalid config location');
+  });
+
+  o('should Not working with wrong protocol', async () => {
+    const error = await ConfigLoader.load(
+      mockUrlRequest('/v1/tiles/🦄 🌈/NZTM2000Quad/tile.json', `?config=memory1://linz-basemaps/config`, Api.header),
+    )
+      .then(() => null)
+      .catch((e) => e);
+
+    o(error instanceof LambdaHttpResponse).equals(true);
+    o((error as LambdaHttpResponse).status).equals(400);
+    o((error as LambdaHttpResponse).statusDescription).equals('Invalid configuration location protocol:memory1');
+  });
+
+  o('should Not working with wrong s3 bucket', async () => {
+    const error = await ConfigLoader.load(
+      mockUrlRequest('/v1/tiles/🦄 🌈/NZTM2000Quad/tile.json', `?config=s3://wrong-bucket/config`, Api.header),
+    )
+      .then(() => null)
+      .catch((e) => e);
+
+    o(error instanceof LambdaHttpResponse).equals(true);
+    o((error as LambdaHttpResponse).status).equals(400);
+    o((error as LambdaHttpResponse).statusDescription).equals(
+      'Bucket: "wrong-bucket" is not a allowed bucket location',
+    );
+  });
+
+  const location = 'memory://linz-basemaps/config.json';
+
+  o('should Not working with no file in the path', async () => {
+    const error = await ConfigLoader.load(
+      mockUrlRequest('/v1/tiles/🦄 🌈/NZTM2000Quad/tile.json', `?config=${location}`, Api.header),
+    )
+      .then(() => null)
+      .catch((e) => e);
+
+    o(error instanceof LambdaHttpResponse).equals(true);
+    o((error as LambdaHttpResponse).status).equals(404);
+    o((error as LambdaHttpResponse).statusDescription).equals(`Config not found at ${location}`);
+  });
+
+  o('should get expected config file', async () => {
+    const expectedConfig = new ConfigProviderMemory();
+    expectedConfig.put(FakeData.tileSetRaster('aerial'));
+    await fsa.write(location, Buffer.from(JSON.stringify(expectedConfig.toJson())));
+
+    const provider = await ConfigLoader.load(
+      mockUrlRequest('/v1/tiles/🦄 🌈/NZTM2000Quad/tile.json', `?config=${location}`, Api.header),
+    );
+
+    o(await provider.Imagery.get('aerial')).deepEquals(await expectedConfig.Imagery.get('aerial'));
+  });
+
+  o('should get expected config file with base58 location', async () => {
+    const expectedConfig = new ConfigProviderMemory();
+    expectedConfig.put(FakeData.tileSetVector('topographic'));
+    await fsa.write(location, Buffer.from(JSON.stringify(expectedConfig.toJson())));
+
+    const provider = await ConfigLoader.load(
+      mockUrlRequest(
+        '/v1/tiles/🦄 🌈/NZTM2000Quad/tile.json',
+        `?config=${base58.encode(Buffer.from(location))}`,
+        Api.header,
+      ),
+    );
+
+    o(await provider.Imagery.get('topographic')).deepEquals(await expectedConfig.Imagery.get('topographic'));
+  });
+});

package/src/util/assets.provider.ts

@@ -1,5 +1,6 @@
 import { fsa } from '@chunkd/fs';
 import { LambdaHttpResponse, LambdaHttpRequest, HttpHeader } from '@linzjs/lambda';
+import { ConfigLoader } from './config.loader.js';
 import { isGzip } from './cotar.serve.js';
 import { Etag } from './etag.js';
 import { NotFound, NotModified } from './response.js';
@@ -15,21 +16,13 @@ export class AssetProvider {
    * s3://linz-basemaps/assets/assets-b4ff211a.tar.co # Remote Cotar
    */
 
-  /** Path of the assets location */
-  path: string | undefined;
-
-  set(path?: string): void {
-    this.path = path;
-  }
-
-  async get(fileName: string): Promise<Buffer | null> {
-    if (this.path == null) return null;
+  async get(path: string, fileName: string): Promise<Buffer | null> {
     // get assets file from cotar
-    if (this.path.endsWith('.tar.co')) return await this.getFromCotar(this.path, fileName);
+    if (path.endsWith('.tar.co')) return await this.getFromCotar(path, fileName);
 
     // get assets file for directory
     try {
-      const filePath = fsa.join(this.path, fileName);
+      const filePath = fsa.join(path, fileName);
       return await fsa.read(filePath);
     } catch (e: any) {
       if (e.code === 404) return null;
@@ -51,7 +44,10 @@ export class AssetProvider {
    * - Content-Type from the parameter contentType
    */
   async serve(req: LambdaHttpRequest, file: string, contentType: string): Promise<LambdaHttpResponse> {
-    const buf = await assetProvider.get(file);
+    const config = await ConfigLoader.load(req);
+    if (config == null) return NotFound();
+    if (config.assets == null) return NotFound();
+    const buf = await assetProvider.get(config.assets, file);
     if (buf == null) return NotFound();
     const cacheKey = Etag.key(buf);
     if (Etag.isNotModified(req, cacheKey)) return NotModified();

package/src/util/config.cache.ts

@@ -1,16 +1,21 @@
 import { ConfigBundled, ConfigProviderMemory } from '@basemaps/config';
-import { fsa } from '@chunkd/fs';
+import { fsa } from '@basemaps/shared';
 import { SwappingLru } from './swapping.lru.js';
 
 class LruConfig {
-  configProvider: Promise<ConfigProviderMemory>;
+  configProvider: Promise<ConfigProviderMemory | null>;
 
   constructor(config: Promise<ConfigBundled>) {
-    this.configProvider = config.then((c) => {
-      const configProvider = ConfigProviderMemory.fromJson(c);
-      configProvider.createVirtualTileSets();
-      return configProvider;
-    });
+    this.configProvider = config
+      .then((c) => {
+        const configProvider = ConfigProviderMemory.fromJson(c);
+        configProvider.createVirtualTileSets();
+        return configProvider;
+      })
+      .catch((e) => {
+        if (e.code === 404) return null;
+        throw e;
+      });
   }
 
   get size(): number {
@@ -25,20 +30,15 @@ export class ConfigCache {
     this.cache = new SwappingLru<LruConfig>(maxSize);
   }
 
-  getConfig(location: string): Promise<ConfigProviderMemory | null> {
+  get(location: string): Promise<ConfigProviderMemory | null> {
     const existing = this.cache.get(location)?.configProvider;
     if (existing != null) return existing;
-    try {
-      const configJson = fsa.readJson<ConfigBundled>(location);
-      const config = new LruConfig(configJson);
-      this.cache.set(location, config);
-      return config.configProvider;
-    } catch (e: any) {
-      if (e.code === 404) return Promise.resolve(null);
-      throw e;
-    }
+    const configJson = fsa.readJson<ConfigBundled>(location);
+    const config = new LruConfig(configJson);
+    this.cache.set(location, config);
+    return config.configProvider;
   }
 }
 
-/** Cache 20 configs(Around 500KB each)*/
+/** Cache 20 configs (Around <30KB -> 5MB each)*/
 export const CachedConfig = new ConfigCache(20);

package/src/util/config.loader.ts

@@ -0,0 +1,56 @@
+import { base58, BasemapsConfigProvider, isBase58 } from '@basemaps/config';
+import { LambdaHttpResponse } from '@linzjs/lambda';
+import { parseUri } from '@chunkd/core';
+import { LambdaHttpRequest } from '@linzjs/lambda';
+import { CachedConfig } from './config.cache.js';
+import { getDefaultConfig } from '@basemaps/shared';
+
+// FIXME load this from process.env COG BUCKETS?
+const SafeBuckets = new Set(['linz-workflow-artifacts', 'linz-basemaps']);
+const SafeProtocols = new Set(['s3', 'memory']);
+
+export class ConfigLoader {
+  /** Exposed for testing */
+  static async getDefaultConfig(): Promise<BasemapsConfigProvider> {
+    const config = getDefaultConfig();
+    if (config.assets == null) {
+      const cb = await config.ConfigBundle.get(config.ConfigBundle.id('latest'));
+      if (cb == null) throw new LambdaHttpResponse(400, 'Unable to get lastest config bundle for asset.');
+      config.assets = cb.assets;
+    }
+    return config;
+  }
+
+  /** Lookup the config path from a request and return a standardized location */
+  static extract(req: LambdaHttpRequest): string | null {
+    const rawLocation = req.query.get('config');
+    if (rawLocation == null) return null;
+    if (rawLocation.includes('/')) return base58.encode(Buffer.from(rawLocation));
+    return rawLocation;
+  }
+
+  static async load(req: LambdaHttpRequest): Promise<BasemapsConfigProvider> {
+    const rawLocation = req.query.get('config');
+    if (rawLocation == null) return this.getDefaultConfig();
+
+    const configLocation = isBase58(rawLocation) ? Buffer.from(base58.decode(rawLocation)).toString() : rawLocation;
+
+    const r = parseUri(configLocation);
+
+    if (r == null) throw new LambdaHttpResponse(400, 'Invalid config location');
+    if (!SafeProtocols.has(r.protocol)) {
+      throw new LambdaHttpResponse(400, `Invalid configuration location protocol:${r.protocol}`);
+    }
+    if (!SafeBuckets.has(r.bucket)) {
+      throw new LambdaHttpResponse(400, `Bucket: "${r.bucket}" is not a allowed bucket location`);
+    }
+
+    req.set('config', configLocation);
+    req.timer.start('config:load');
+    return CachedConfig.get(configLocation).then((f) => {
+      req.timer.end('config:load');
+      if (f == null) throw new LambdaHttpResponse(404, `Config not found at ${configLocation}`);
+      return f;
+    });
+  }
+}

package/src/wmts.capability.ts

@@ -1,6 +1,6 @@
-import { Config, ConfigImagery, ConfigLayer, ConfigTileSet, standardizeLayerName } from '@basemaps/config';
+import { ConfigImagery, ConfigLayer, ConfigTileSet, standardizeLayerName } from '@basemaps/config';
 import { Bounds, GoogleTms, ImageFormat, TileMatrixSet, WmtsProvider } from '@basemaps/geo';
-import { Projection, V, VNodeElement } from '@basemaps/shared';
+import { Projection, toQueryString, V, VNodeElement } from '@basemaps/shared';
 import { ImageFormatOrder } from '@basemaps/tiler';
 import { BoundingBox } from '@cogeotiff/core';
 import { BBox } from '@linzjs/geojson';
@@ -36,6 +36,8 @@ export interface WmtsCapabilitiesParams {
   apiKey?: string;
   /** Limit the output to the following image formats other wise @see ImageFormatOrder */
   formats?: ImageFormat[] | null;
+  /** Config location */
+  config?: string | null;
 }
 
 /** Number of decimal places to use in lat lng */
@@ -56,6 +58,7 @@ export class WmtsCapabilities {
   provider?: WmtsProvider;
   tileSet: ConfigTileSet;
   apiKey?: string;
+  config?: string | null;
   tileMatrixSets = new Map<string, TileMatrixSet>();
   imagery: Map<string, ConfigImagery>;
   formats: ImageFormat[];
@@ -65,6 +68,7 @@ export class WmtsCapabilities {
     this.httpBase = params.httpBase;
     this.provider = params.provider;
     this.tileSet = params.tileSet;
+    this.config = params.config;
     this.isIndividualLayers = params.isIndividualLayers;
     for (const tms of params.tileMatrix) this.tileMatrixSets.set(tms.identifier, tms);
     this.apiKey = params.apiKey;
@@ -72,17 +76,6 @@ export class WmtsCapabilities {
     this.imagery = params.imagery;
   }
 
-  async loadImagery(): Promise<void> {
-    const ids = new Set<string>();
-    for (const tms of this.tileMatrixSets.values()) {
-      for (const layer of this.tileSet.layers) {
-        const layerId = layer[tms.projection.code];
-        if (layerId != null) ids.add(layerId);
-      }
-    }
-    this.imagery = await Config.Imagery.getAll(ids);
-  }
-
   buildWgs84BoundingBox(tms: TileMatrixSet, layers: Bounds[]): VNodeElement {
     let bbox: BBox;
     if (layers.length > 0) {
@@ -164,7 +157,8 @@ export class WmtsCapabilities {
   }
 
   buildTileUrl(tileSetId: string, suffix: string): string {
-    const apiSuffix = this.apiKey ? `?api=${this.apiKey}` : '';
+    const query = toQueryString({ api: this.apiKey, config: this.config });
+
     return [
       this.httpBase,
       'v1',
@@ -173,7 +167,7 @@ export class WmtsCapabilities {
       '{TileMatrixSet}',
       '{TileMatrix}',
       '{TileCol}',
-      `{TileRow}.${suffix}${apiSuffix}`,
+      `{TileRow}.${suffix}${query}`,
     ].join('/');
   }