@basemaps/lambda-tiler 6.40.0 → 6.43.0

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

@@ -24,15 +24,17 @@ o.spec('WmtsCapabilities', () => {
   o('should output the requested formats', () => {
     const wmts = new WmtsCapabilities({
       httpBase: 'https://basemaps.test',
-      provider: Provider,
-      tileMatrix: [GoogleTms],
-      tileSet: TileSetAerial,
-      imagery: allImagery,
       apiKey,
-      formats: [ImageFormat.Avif],
-    }).toVNode();
+    });
 
-    const urls = tags(wmts, 'ResourceURL');
+    wmts.addTileMatrix(GoogleTms);
+    for (const im of allImagery.values()) wmts.addImagery(im);
+    wmts.addFormats(ImageFormat.Avif);
+    wmts.addProvider(Provider);
+    wmts.addTileSet(TileSetAerial);
+    const wmtsCapability = wmts.toVNode();
+
+    const urls = tags(wmtsCapability, 'ResourceURL');
     o(urls.length).equals(1);
     o(urls[0].attrs.format).equals('image/avif');
     o(urls[0].attrs.template).equals(
@@ -43,16 +45,18 @@ o.spec('WmtsCapabilities', () => {
   o('should include config location', () => {
     const wmts = new WmtsCapabilities({
       httpBase: 'https://basemaps.test',
-      provider: Provider,
-      tileMatrix: [GoogleTms],
-      tileSet: TileSetAerial,
-      imagery: allImagery,
       apiKey,
       config: 's3://linz-basemaps/config.json',
-      formats: [ImageFormat.Avif],
-    }).toVNode();
+    });
+
+    wmts.addTileMatrix(GoogleTms);
+    for (const im of allImagery.values()) wmts.addImagery(im);
+    wmts.addFormats(ImageFormat.Avif);
+    wmts.addProvider(Provider);
+    wmts.addTileSet(TileSetAerial);
+    const wmtsCapability = wmts.toVNode();
 
-    const urls = tags(wmts, 'ResourceURL');
+    const urls = tags(wmtsCapability, 'ResourceURL');
     o(urls.length).equals(1);
     o(urls[0].attrs.format).equals('image/avif');
     o(urls[0].attrs.template).equals(
@@ -60,16 +64,20 @@ o.spec('WmtsCapabilities', () => {
     );
   });
 
-  o('should be seting encoding to utf-8', () => {
-    const xml = new WmtsCapabilities({
+  o('should be adding encoding to utf-8', () => {
+    const wmts = new WmtsCapabilities({
       httpBase: 'https://basemaps.test',
+      apiKey,
+    });
+
+    wmts.fromParams({
       provider: Provider,
       tileMatrix: [GoogleTms],
       tileSet: TileSetAerial,
       imagery: allImagery,
-      apiKey,
       formats: [ImageFormat.Avif],
-    }).toXml();
+    });
+    const xml = wmts.toXml();
 
     o(xml.split('\n')[0]).deepEquals('<?xml version="1.0" encoding="utf-8"?>');
   });
@@ -79,23 +87,26 @@ o.spec('WmtsCapabilities', () => {
     tileSet.name = '🦄_🌈_2022_0-5m';
     tileSet.title = '🦄 🌈 Imagery (2022)';
     tileSet.description = '🦄 🌈 Description';
+
     const wmts = new WmtsCapabilities({
       httpBase: 'https://basemaps.test',
-      provider: Provider,
-      tileMatrix: [GoogleTms],
-      tileSet,
-      imagery: allImagery,
       apiKey,
-      formats: [ImageFormat.Avif],
-    }).toVNode();
+    });
 
-    const urls = tags(wmts, 'ResourceURL');
+    wmts.addTileMatrix(GoogleTms);
+    for (const im of allImagery.values()) wmts.addImagery(im);
+    wmts.addFormats(ImageFormat.Avif);
+    wmts.addProvider(Provider);
+    wmts.addTileSet(tileSet);
+    const wmtsCapability = wmts.toVNode();
+
+    const urls = tags(wmtsCapability, 'ResourceURL');
     o(urls.length).equals(1);
     o(urls[0].attrs.template).equals(
       'https://basemaps.test/v1/tiles/🦄-🌈-2022-0.5m/{TileMatrixSet}/{TileMatrix}/{TileCol}/{TileRow}.avif?api=secret1234',
     );
 
-    const layer = tags(wmts, 'Layer')[0];
+    const layer = tags(wmtsCapability, 'Layer')[0];
 
     const title = layer.find('ows:Title')?.toString();
     o(title).equals('<ows:Title>🦄 🌈 Imagery (2022)</ows:Title>');
@@ -133,32 +144,36 @@ o.spec('WmtsCapabilities', () => {
 
     const wmts = new WmtsCapabilities({
       httpBase: 'https://basemaps.test',
-      provider: Provider,
-      tileMatrix: [GoogleTms],
-      tileSet,
-      imagery,
       apiKey,
-      layers: tileSet.layers,
-    }).toVNode();
+    });
+
+    wmts.addTileMatrix(GoogleTms);
+    for (const im of imagery.values()) wmts.addImagery(im);
+    wmts.addProvider(Provider);
+    wmts.addTileSet(tileSet);
+    wmts.addLayers(tileSet.layers);
+    const wmtsCapability = wmts.toVNode();
 
-    const layers = tags(wmts, 'Layer').map((c) => c.find('ows:Title')?.textContent);
+    const layers = tags(wmtsCapability, 'Layer').map((c) => c.find('ows:Title')?.textContent);
 
     // The base layer "Aerial Imagery" should always be first then all sub layers after
     o(layers).deepEquals(['Aerial Imagery', 'aaaa', 'bbbb', 'Ōtorohanga 0.1m Urban Aerial Photos (2021)']);
   });
 
-  o('should build capability xml for tileset and projection', () => {
+  o('should build capability xml for tileSet and projection', () => {
     const imagery = new Map();
     imagery.set(Imagery3857.id, Imagery3857);
+
     const wmts = new WmtsCapabilities({
       httpBase: 'https://basemaps.test',
-      provider: Provider,
-      tileMatrix: [GoogleTms],
-      tileSet: TileSetAerial,
-      imagery,
       apiKey,
     });
 
+    wmts.addTileMatrix(GoogleTms);
+    for (const im of imagery.values()) wmts.addImagery(im);
+    wmts.addProvider(Provider);
+    wmts.addTileSet(TileSetAerial);
+    wmts.addLayers(TileSetAerial.layers);
     const raw = wmts.toVNode();
     const serviceId = raw.find('ows:ServiceIdentification');
 
@@ -201,14 +216,17 @@ o.spec('WmtsCapabilities', () => {
   });
 
   o('should include output the correct TileMatrix', () => {
-    const raw = new WmtsCapabilities({
+    const wmts = new WmtsCapabilities({
       httpBase: 'https://basemaps.test',
-      provider: Provider,
-      tileMatrix: [GoogleTms],
-      tileSet: TileSetAerial,
-      imagery: allImagery,
       apiKey,
-    }).toVNode();
+    });
+
+    wmts.addTileMatrix(GoogleTms);
+    for (const im of allImagery.values()) wmts.addImagery(im);
+    wmts.addProvider(Provider);
+    wmts.addTileSet(TileSetAerial);
+    const raw = wmts.toVNode();
+
     const layer = raw.find('Contents', 'Layer');
 
     o(layer?.find('TileMatrixSetLink', 'TileMatrixSet')?.textContent).equals('WebMercatorQuad');
@@ -243,19 +261,25 @@ o.spec('WmtsCapabilities', () => {
     compareMatrix(tileMatrices[10], '10', 1024, 545978.773465544);
   });
 
-  o('should output individual imagery sets', () => {
+  o('should output individual imagery adds', () => {
     const imagery = new Map<string, ConfigImagery>();
     imagery.set(Imagery3857.id, Imagery3857);
     imagery.set(Imagery2193.id, Imagery2193);
-    const raw = new WmtsCapabilities({
+
+    const wmts = new WmtsCapabilities({
       httpBase: 'https://basemaps.test',
+    });
+
+    wmts.fromParams({
       provider: Provider,
       tileMatrix: [GoogleTms],
       tileSet: TileSetAerial,
-      imagery: imagery,
-      formats: [ImageFormat.Png],
+      imagery,
       layers: TileSetAerial.layers,
-    }).toVNode();
+      formats: [ImageFormat.Png],
+    });
+
+    const raw = wmts.toVNode();
 
     const tms = raw?.find('TileMatrixSet', 'ows:Identifier');
 
@@ -286,15 +310,20 @@ o.spec('WmtsCapabilities', () => {
     const imagery = new Map<string, ConfigImagery>();
     imagery.set(Imagery3857.id, Imagery3857);
     imagery.set(Imagery2193.id, Imagery2193);
-    const raw = new WmtsCapabilities({
+
+    const wmts = new WmtsCapabilities({
       httpBase: 'https://basemaps.test',
+    });
+
+    wmts.fromParams({
       provider: Provider,
       tileMatrix: [GoogleTms, Nztm2000QuadTms],
       tileSet: TileSetAerial,
       imagery: imagery,
       formats: [ImageFormat.Png],
-    }).toVNode();
+    });
 
+    const raw = wmts.toVNode();
     const layers = tags(raw, 'Layer');
     o(layers.length).equals(1);
     const layer = layers[0];
@@ -321,11 +350,11 @@ o.spec('WmtsCapabilities', () => {
     );
     o(layer.find('ows:Identifier')?.textContent).equals('aerial');
 
-    const sets = tags(layer, 'TileMatrixSet');
+    const adds = tags(layer, 'TileMatrixSet');
 
-    o(sets.length).equals(2);
-    o(sets[0].toString()).equals('<TileMatrixSet>WebMercatorQuad</TileMatrixSet>');
-    o(sets[1].toString()).equals('<TileMatrixSet>NZTM2000Quad</TileMatrixSet>');
+    o(adds.length).equals(2);
+    o(adds[0].toString()).equals('<TileMatrixSet>WebMercatorQuad</TileMatrixSet>');
+    o(adds[1].toString()).equals('<TileMatrixSet>NZTM2000Quad</TileMatrixSet>');
 
     const boundingBoxes = tags(layer, 'ows:BoundingBox');
     o(boundingBoxes.length).equals(2);
@@ -347,37 +376,45 @@ o.spec('WmtsCapabilities', () => {
 
   o('should only output imagery if exists', () => {
     const imagery = new Map<string, ConfigImagery>();
-    const raw = new WmtsCapabilities({
+    const wmtsA = new WmtsCapabilities({
       httpBase: 'https://basemaps.test',
+    });
+
+    wmtsA.fromParams({
       provider: Provider,
       tileMatrix: [Nztm2000QuadTms],
       tileSet: TileSetAerial,
       imagery: imagery,
       formats: [ImageFormat.Png],
       layers: TileSetAerial.layers,
-    }).toVNode();
+    });
 
-    const layers = tags(raw, 'Layer');
+    const rawA = wmtsA.toVNode();
+
+    const layers = tags(rawA, 'Layer');
     o(layers.length).equals(1);
 
     imagery.set(Imagery3857.id, Imagery3857);
-    const rawB = new WmtsCapabilities({
+    const wmtsB = new WmtsCapabilities({
       httpBase: 'https://basemaps.test',
+    });
+    wmtsB.fromParams({
       provider: Provider,
       tileMatrix: [Nztm2000QuadTms],
       tileSet: TileSetAerial,
       imagery: imagery,
       formats: [ImageFormat.Png],
       layers: TileSetAerial.layers,
-    }).toVNode();
+    });
 
+    const rawB = wmtsB.toVNode();
     const layersB = tags(rawB, 'Layer');
     o(layersB.length).equals(1);
   });
 
   o('should cover the entire WebMercatorBounds', () => {
     const halfSize = GoogleTms.extent.width / 2;
-    // Create two fake imagery sets one covers tile z1 x0 y0 another covers tile z1 x1 y1
+    // Create two fake imagery adds one covers tile z1 x0 y0 another covers tile z1 x1 y1
     // so the entire bounding box should be tile z0 x0 y0 or the full extent
     const imagery = new Map();
     const imageTopLeft = { ...Imagery3857, id: 'im_top_left', name: 'top_left' };
@@ -394,15 +431,19 @@ o.spec('WmtsCapabilities', () => {
       { 3857: imageBottomRight.id, name: 'b_bottom_right', title: 'B Bottom Right' },
     ];
 
-    const raw = new WmtsCapabilities({
+    const wmts = new WmtsCapabilities({
       httpBase: 'https://basemaps.test',
+    });
+    wmts.fromParams({
       provider: Provider,
       tileMatrix: [GoogleTms],
       tileSet,
       imagery,
       formats: [ImageFormat.Png],
       layers: tileSet.layers,
-    }).toVNode();
+    });
+
+    const raw = wmts.toVNode();
 
     const boundingBox = tags(raw, 'ows:WGS84BoundingBox').map((c) =>
       c
@@ -433,15 +474,19 @@ o.spec('WmtsCapabilities', () => {
     const tileSet = { ...TileSetAerial };
     tileSet.layers = [{ 3857: imageBottomRight.id, name: 'b_bottom_right', title: 'B Bottom Right' }];
 
-    const raw = new WmtsCapabilities({
+    const wmts = new WmtsCapabilities({
       httpBase: 'https://basemaps.test',
+    });
+    wmts.fromParams({
       provider: Provider,
       tileMatrix: [GoogleTms],
       tileSet,
       imagery,
       formats: [ImageFormat.Png],
       layers: tileSet.layers,
-    }).toVNode();
+    });
+
+    const raw = wmts.toVNode();
 
     const boundingBox = tags(raw, 'ows:WGS84BoundingBox').map((c) =>
       roundNumbersInString(c.toString(), 4)

package/src/cli/render.tile.ts

@@ -1,38 +1,57 @@
 import { ConfigProviderMemory } from '@basemaps/config';
-import { initConfigFromPaths } from '@basemaps/config/build/json/tiff.config.js';
-import { ImageFormat, Nztm2000QuadTms } from '@basemaps/geo';
+import { initConfigFromUrls } from '@basemaps/config/build/json/tiff.config.js';
+import { ImageFormat, Tile, TileMatrixSet, TileMatrixSets } from '@basemaps/geo';
 import { LogConfig, setDefaultConfig } from '@basemaps/shared';
 import { fsa } from '@chunkd/fs';
 import { LambdaHttpRequest, LambdaUrlRequest, UrlEvent } from '@linzjs/lambda';
 import { Context } from 'aws-lambda';
+import { pathToFileURL } from 'url';
 import { TileXyzRaster } from '../routes/tile.xyz.raster.js';
 
-const target = `/home/blacha/tmp/basemaps`;
-const tile = { z: 18, x: 126359, y: 137603 };
-const tileMatrix = Nztm2000QuadTms;
+const target = pathToFileURL(`/home/blacha/tmp/imagery/southland-0.25-rural-2023/`);
+const tile = fromPath('/18/117833/146174.webp');
+
+const outputFormat = ImageFormat.Webp;
+let tileMatrix: TileMatrixSet | null = null;
+
+/** Convert a tile path /:z/:x/:y.png into a tile */
+function fromPath(s: string): Tile {
+  const parts = s.split('.')[0].split('/').map(Number);
+  if (s.startsWith('/')) parts.shift();
+  if (parts.length !== 3) throw new Error(`Invalid tile path ${s}`);
+  return { z: parts[0], x: parts[1], y: parts[2] };
+}
 
 async function main(): Promise<void> {
   const log = LogConfig.get();
   const provider = new ConfigProviderMemory();
   setDefaultConfig(provider);
-  const { tileSet, imagery } = await initConfigFromPaths(provider, [target]);
+  const { tileSet, imagery } = await initConfigFromUrls(provider, [target]);
 
   if (tileSet.layers.length === 0) throw new Error('No imagery found in path: ' + target);
   log.info({ tileSet: tileSet.name, layers: tileSet.layers.length }, 'TileSet:Loaded');
+
   for (const im of imagery) {
-    log.info({ imagery: im.uri, title: im.title, tileMatrix: im.tileMatrix, files: im.files.length }, 'Imagery:Loaded');
+    log.info({ url: im.uri, title: im.title, tileMatrix: im.tileMatrix, files: im.files.length }, 'Imagery:Loaded');
+    if (tileMatrix == null) {
+      tileMatrix = TileMatrixSets.find(im.tileMatrix);
+      log.info({ tileMatrix: im.tileMatrix }, 'Imagery:TileMatrix:Set');
+    }
   }
+
+  if (tileMatrix == null) throw new Error('No tileMatrix found');
   const request = new LambdaUrlRequest({ headers: {} } as UrlEvent, {} as Context, log) as LambdaHttpRequest;
 
+  tileSet.background = { r: 255, g: 0, b: 255, alpha: 0.25 };
   const res = await TileXyzRaster.tile(request, tileSet, {
     tile,
     tileMatrix,
     tileSet: tileSet.id,
-    tileType: ImageFormat.Png,
+    tileType: outputFormat,
   });
 
-  await fsa.write(`./${tile.z}_${tile.x}_${tile.y}.png`, Buffer.from(res.body, 'base64'));
-  log.info({ path: `./${tile.z}_${tile.x}_${tile.y}.png` }, 'Tile:Write');
+  await fsa.write(`./${tile.z}_${tile.x}_${tile.y}.${outputFormat}`, Buffer.from(res.body, 'base64'));
+  log.info({ path: `./${tile.z}_${tile.x}_${tile.y}.${outputFormat}` }, 'Tile:Write');
 }
 
 main();

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

@@ -1,7 +1,7 @@
 import { Attribution } from '@basemaps/attribution';
 import { ConfigProviderMemory } from '@basemaps/config';
-import { GoogleTms, Nztm2000QuadTms } from '@basemaps/geo';
-import { LogConfig, Projection } from '@basemaps/shared';
+import { GoogleTms, Nztm2000QuadTms, Projection } from '@basemaps/geo';
+import { LogConfig } from '@basemaps/shared';
 import { BBox } from '@linzjs/geojson';
 import { HttpHeader } from '@linzjs/lambda';
 import o from 'ospec';

package/src/routes/attribution.ts

@@ -6,13 +6,14 @@ import {
   Bounds,
   GoogleTms,
   NamedBounds,
+  Projection,
   Stac,
   StacExtent,
   StacProvider,
   TileMatrixSet,
 } from '@basemaps/geo';
-import { extractYearRangeFromName, extractYearRangeFromTitle, Projection } from '@basemaps/shared';
 import { BBox, MultiPolygon, multiPolygonToWgs84, Pair, union, Wgs84 } from '@linzjs/geojson';
+import { extractYearRangeFromName, extractYearRangeFromTitle } from '@basemaps/shared';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import { ConfigLoader } from '../util/config.loader.js';
 
@@ -88,16 +89,21 @@ async function tileSetAttribution(
   const host = await config.Provider.get(config.Provider.id('linz'));
 
   for (const layer of filteredLayers) {
-    if (layer.disabled) continue;
     const imgId = layer[proj.epsg.code];
     if (imgId == null) continue;
     const im = imagery.get(imgId);
     if (im == null) continue;
     const title = im.title;
+    const years = extractYearRangeFromTitle(im.title) ?? extractYearRangeFromName(im.name);
+    if (years == null) continue;
+    const interval = yearRangeToInterval(years);
 
     const bbox = proj.boundsToWgs84BoundingBox(im.bounds).map(roundNumber) as BBox;
 
-    const extent: StacExtent = { spatial: { bbox: [bbox] } };
+    const extent: StacExtent = {
+      spatial: { bbox: [bbox] },
+      temporal: { interval: [[interval[0].toISOString(), interval[1].toISOString()]] },
+    };
 
     const item: AttributionItem = {
       type: 'Feature',
@@ -111,16 +117,12 @@ async function tileSetAttribution(
       properties: {
         title,
         category: im.category,
+        datetime: null,
+        start_datetime: interval[0].toISOString(),
+        end_datetime: interval[1].toISOString(),
       },
     };
-    const years = extractYearRangeFromTitle(im.title) ?? extractYearRangeFromName(im.name);
-    if (years) {
-      const interval = yearRangeToInterval(years);
-      extent.temporal = { interval: [[interval[0].toISOString(), interval[1].toISOString()]] };
-      item.properties.datetime = null;
-      item.properties.start_datetime = interval[0].toISOString();
-      item.properties.end_datetime = interval[1].toISOString();
-    }
+
     items.push(item);
 
     const zoomMin = TileMatrixSet.convertZoomLevel(layer.minZoom ? layer.minZoom : 0, GoogleTms, tileMatrix, true);

package/src/routes/tile.wmts.ts

@@ -55,18 +55,23 @@ export async function wmtsCapabilitiesGet(req: LambdaHttpRequest<WmtsCapabilitie
   );
   req.timer.end('imagery:load');
 
-  const xml = new WmtsCapabilities({
+  const wmts = new WmtsCapabilities({
     httpBase: host,
+    apiKey,
+    config: ConfigLoader.extract(req),
+    filters: getFilters(req),
+  });
+
+  wmts.fromParams({
     provider: provider ?? undefined,
     tileSet,
     tileMatrix,
     imagery,
-    apiKey,
-    config: ConfigLoader.extract(req),
-    formats: Validate.getRequestedFormats(req),
-    layers: req.params.tileMatrix == null ? filterLayers(req, tileSet.layers) : null,
-    filters: getFilters(req),
-  }).toXml();
+    formats: Validate.getRequestedFormats(req) ?? [],
+    layers: req.params.tileMatrix == null ? filterLayers(req, tileSet.layers) : undefined,
+  });
+
+  const xml = wmts.toXml();
   if (xml == null) return NotFound();
 
   const data = Buffer.from(xml);

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

@@ -41,7 +41,6 @@ export const TileXyzRaster = {
     // All zoom level config is stored as Google zoom levels
     const filterZoom = TileMatrixSet.convertZoomLevel(xyz.tile.z, xyz.tileMatrix, TileMatrixSets.get(Epsg.Google));
     for (const layer of filteredLayers) {
-      if (layer.disabled) continue;
       if (layer.maxZoom != null && filterZoom > layer.maxZoom) continue;
       if (layer.minZoom != null && filterZoom < layer.minZoom) continue;
 

package/src/routes/version.ts

@@ -3,6 +3,22 @@ import { HttpHeader, LambdaHttpResponse } from '@linzjs/lambda';
 export async function versionGet(): Promise<LambdaHttpResponse> {
   const response = new LambdaHttpResponse(200, 'ok');
   response.header(HttpHeader.CacheControl, 'no-store');
-  response.json({ version: process.env.GIT_VERSION ?? 'dev', hash: process.env.GIT_HASH });
+  response.json({
+    /**
+     * last git version tag
+     * @example "v6.42.1"
+     */
+    version: process.env.GIT_VERSION ?? 'dev',
+    /**
+     * Full git commit hash
+     * @example "e4231b1ee62c276c8657c56677ced02681dfe5d6"
+     */
+    hash: process.env.GIT_HASH,
+    /**
+     * The exact build that this release was run from
+     * @example "1658821493-3"
+     */
+    buildId: process.env.BUILD_ID,
+  });
   return response;
 }

package/src/util/validate.ts

@@ -1,5 +1,5 @@
-import { ImageFormat, TileMatrixSet, TileMatrixSets, VectorFormat } from '@basemaps/geo';
-import { Const, isValidApiKey, Projection } from '@basemaps/shared';
+import { ImageFormat, Projection, TileMatrixSet, TileMatrixSets, VectorFormat } from '@basemaps/geo';
+import { Const, isValidApiKey, truncateApiKey } from '@basemaps/shared';
 import { getImageFormat } from '@basemaps/tiler';
 import { LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import { TileXyzGet } from '../routes/tile.xyz';
@@ -25,7 +25,8 @@ export const Validate = {
     const valid = isValidApiKey(apiKey);
 
     if (!valid.valid) throw new LambdaHttpResponse(400, 'API Key Invalid: ' + valid.message);
-    req.set('api', apiKey);
+    // Truncate the API Key so we are not logging the full key
+    req.set('api', truncateApiKey(apiKey));
     return apiKey as string;
   },