@basemaps/lambda-tiler 6.39.0 → 6.41.0

package/src/routes/attribution.ts

@@ -6,17 +6,19 @@ import {
   Bounds,
   GoogleTms,
   NamedBounds,
+  Projection,
   Stac,
   StacExtent,
   StacProvider,
   TileMatrixSet,
 } from '@basemaps/geo';
-import { extractYearRangeFromName, Projection, titleizeImageryName } 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';
 
 import { Etag } from '../util/etag.js';
+import { filterLayers, yearRangeToInterval } from '../util/filter.js';
 import { NotFound, NotModified } from '../util/response.js';
 import { Validate } from '../util/validate.js';
 
@@ -44,23 +46,19 @@ function roundPair(p: Pair): Pair {
  * @param files in target projection
  * @return MultiPolygon in WGS84
  */
-function createCoordinates(bbox: BBox, files: NamedBounds[], proj: Projection): MultiPolygon {
+export function createCoordinates(bbox: BBox, files: NamedBounds[], proj: Projection): MultiPolygon {
   if (Wgs84.delta(bbox[0], bbox[2]) <= 0) {
     // This bounds spans more than half the globe which multiPolygonToWgs84 can't handle; just
     // return bbox as polygon
     return Wgs84.bboxToMultiPolygon(bbox);
   }
 
-  let coordinates: MultiPolygon = [];
-
+  const polygons: MultiPolygon = [];
   // merge imagery bounds
-  for (const image of files) {
-    const poly = [Bounds.fromJson(image).pad(SmoothPadding).toPolygon()] as MultiPolygon;
-    coordinates = union(coordinates, poly);
-  }
+  for (const image of files) polygons.push(Bounds.fromJson(image).pad(SmoothPadding).toPolygon());
+  const coordinates = union(polygons);
 
   const roundToWgs84 = (p: number[]): number[] => roundPair(proj.toWgs84(p) as Pair);
-
   return multiPolygonToWgs84(coordinates, roundToWgs84);
 }
 
@@ -86,30 +84,28 @@ async function tileSetAttribution(
 
   const config = await ConfigLoader.load(req);
   const imagery = await getAllImagery(config, tileSet.layers, [tileMatrix.projection]);
+  const filteredLayers = filterLayers(req, tileSet.layers);
 
   const host = await config.Provider.get(config.Provider.id('linz'));
 
-  for (const layer of tileSet.layers) {
+  for (const layer of filteredLayers) {
     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 years = extractYearRangeFromName(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: [[interval[0].toISOString(), interval[1].toISOString()]] },
+    };
 
-    const extent: StacExtent = { spatial: { bbox: [bbox] }, temporal: { interval } };
-
-    items.push({
+    const item: AttributionItem = {
       type: 'Feature',
       stac_version: Stac.Version,
       id: imgId + '_item',
@@ -119,22 +115,25 @@ async function tileSetAttribution(
       bbox,
       geometry: { type: 'MultiPolygon', coordinates: createCoordinates(bbox, im.files, proj) },
       properties: {
-        title: im.title ?? titleizeImageryName(im.name),
+        title,
         category: im.category,
         datetime: null,
-        start_datetime: interval[0][0],
-        end_datetime: interval[0][1],
+        start_datetime: interval[0].toISOString(),
+        end_datetime: interval[1].toISOString(),
       },
-    });
+    };
+
+    items.push(item);
 
-    const zoomMin = TileMatrixSet.convertZoomLevel(layer.minZoom ? layer.minZoom : 0, GoogleTms, tileMatrix, true);
+    const minZoom = layer.disabled ? 32 : layer.minZoom;
+    const zoomMin = TileMatrixSet.convertZoomLevel(minZoom ? minZoom : 0, GoogleTms, tileMatrix, true);
     const zoomMax = TileMatrixSet.convertZoomLevel(layer.maxZoom ? layer.maxZoom : 32, GoogleTms, tileMatrix, true);
     cols.push({
       stac_version: Stac.Version,
       license: Stac.License,
       id: im.id,
       providers: getHost(host),
-      title: im.title ?? titleizeImageryName(im.name),
+      title,
       description: 'No description',
       extent,
       links: [],
@@ -142,6 +141,7 @@ async function tileSetAttribution(
         'linz:category': im.category,
         'linz:zoom': { min: zoomMin, max: zoomMax },
         'linz:priority': [1000 + tileSet.layers.indexOf(layer)],
+        'linz:disabled': layer.disabled ? true : false,
       },
     });
   }

package/src/routes/tile.json.ts

@@ -2,6 +2,7 @@ import { GoogleTms, TileJson, TileMatrixSet } from '@basemaps/geo';
 import { Env, toQueryString } from '@basemaps/shared';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import { ConfigLoader } from '../util/config.loader.js';
+import { getFilters } from '../util/filter.js';
 import { NotFound } from '../util/response.js';
 import { Validate } from '../util/validate.js';
 
@@ -31,7 +32,7 @@ export async function tileJsonGet(req: LambdaHttpRequest<TileJsonGet>): Promise<
 
   const configLocation = ConfigLoader.extract(req);
 
-  const query = toQueryString({ api: apiKey, config: configLocation });
+  const query = toQueryString({ api: apiKey, config: configLocation, ...getFilters(req) });
 
   const tileUrl =
     [host, 'v1', 'tiles', tileSet.name, tileMatrix.identifier, '{z}', '{x}', '{y}'].join('/') + `.${format[0]}${query}`;

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

@@ -8,6 +8,7 @@ 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';
+import { getFilters } from '../util/filter.js';
 
 /**
  * Convert relative URLS into a full hostname url
@@ -73,7 +74,7 @@ export async function tileSetToStyle(
   if (tileFormat == null) return new LambdaHttpResponse(400, 'Invalid image format');
 
   const configLocation = ConfigLoader.extract(req);
-  const query = toQueryString({ config: configLocation, api: apiKey });
+  const query = toQueryString({ config: configLocation, api: apiKey, ...getFilters(req) });
 
   const tileUrl = fsa.join(
     Env.get(Env.PublicUrlBase) ?? '',

package/src/routes/tile.wmts.ts

@@ -8,6 +8,7 @@ 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';
+import { filterLayers, getFilters } from '../util/filter.js';
 
 export interface WmtsCapabilitiesGet {
   Params: {
@@ -54,17 +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,
-    isIndividualLayers: req.params.tileMatrix == null,
     imagery,
-    apiKey,
-    config: ConfigLoader.extract(req),
-    formats: Validate.getRequestedFormats(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

@@ -9,6 +9,7 @@ import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambd
 import pLimit from 'p-limit';
 import { ConfigLoader } from '../util/config.loader.js';
 import { Etag } from '../util/etag.js';
+import { filterLayers } from '../util/filter.js';
 import { NotFound, NotModified } from '../util/response.js';
 import { CoSources } from '../util/source.cache.js';
 import { TileXyz } from '../util/validate.js';
@@ -32,13 +33,15 @@ export const TileXyzRaster = {
   async getAssetsForTile(req: LambdaHttpRequest, tileSet: ConfigTileSetRaster, xyz: TileXyz): Promise<string[]> {
     const config = await ConfigLoader.load(req);
     const imagery = await getAllImagery(config, tileSet.layers, [xyz.tileMatrix.projection]);
+    const filteredLayers = filterLayers(req, tileSet.layers);
 
     const output: string[] = [];
     const tileBounds = xyz.tileMatrix.tileToSourceBounds(xyz.tile);
 
     // 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 tileSet.layers) {
+    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/util/__test__/filter.test.ts

@@ -0,0 +1,80 @@
+import { ConfigLayer } from '@basemaps/config';
+import o from 'ospec';
+import { mockUrlRequest } from '../../__tests__/xyz.util.js';
+import { filterLayers } from '../filter.js';
+
+o.spec('filterLayers', () => {
+  const sourceLayers: ConfigLayer[] = [
+    {
+      name: 'waikato-0_625m-snc12836-2004',
+      title: 'Waikato 0.625m SNC12836 (2004-2008)',
+    },
+    {
+      name: 'hawkes-bay--manawat-whanganui-0_75m-snc30001-2002',
+      title: 'Hawkes Bay / Manawatū-Whanganui 0.75m SNC30001 (2002)',
+    },
+    {
+      name: 'canterbury-0_75m-snc25054-2000-2001',
+      title: 'Canterbury 0.75m SNC25054 (2000-2001)',
+    },
+    {
+      name: 'otago-0_375m-sn3806-1975',
+      title: 'Otago 0.375m SN3806 (1975)',
+    },
+  ];
+
+  o('should not filter with empty parameters', () => {
+    const layers = filterLayers(mockUrlRequest('/foo/bar,js'), sourceLayers);
+    o(layers).deepEquals(sourceLayers);
+  });
+
+  o('should filter date[after]', () => {
+    const dateAfter = '2003-12-31T23:59:59.999';
+    const layers = filterLayers(mockUrlRequest('/foo/bar,js', `?date[after]=${dateAfter}`), sourceLayers);
+    o(layers).deepEquals([sourceLayers[0]]);
+  });
+
+  o('should filter date[before]', () => {
+    const dateBefore = '2003-01-01T00:00:00.000Z';
+    const layers = filterLayers(mockUrlRequest('/foo/bar,js', `?date[before]=${dateBefore}`), sourceLayers);
+    o(layers).deepEquals(sourceLayers.slice(1));
+  });
+
+  o('should filter date[before] in between years', () => {
+    const dateBefore = '2026-01-01T00:00:00.000Z';
+    const layer = [{ name: '', title: 'Waikato 0.625m SNC12836 (2020-2028)' }];
+    const layers = filterLayers(mockUrlRequest('/foo/bar,js', `?date[before]=${dateBefore}`), layer);
+    o(layers).deepEquals(layer);
+  });
+
+  o('should filter date[after] in between years', () => {
+    const dateAfter = '2026-12-31T23:59:59.999Z';
+    const layer = [{ name: '', title: 'Waikato 0.625m SNC12836 (2020-2028)' }];
+    const layers = filterLayers(mockUrlRequest('/foo/bar,js', `?date[after]=${dateAfter}`), layer);
+    o(layers).deepEquals(layer);
+  });
+
+  o('should filter date[after] and date[before] in between years', () => {
+    const dateAfter = '2026-12-31T23:59:59.999Z';
+    const dateBefore = '2028-01-01T00:00:00.000Z';
+
+    const layer = [{ name: '', title: 'Waikato 0.625m SNC12836 (2020-2028)' }];
+    const layers = filterLayers(
+      mockUrlRequest('/foo/bar,js', `?date[after]=${dateAfter}&date[before]=${dateBefore}`),
+      layer,
+    );
+    o(layers).deepEquals(layer);
+  });
+
+  o('should filter date[after] and date[before] in between years with single year', () => {
+    const dateAfter = '2026-12-31T23:59:59.999Z';
+    const dateBefore = '2028-01-01T00:00:00.000Z';
+
+    const layer = [{ name: '', title: 'Waikato 0.625m SNC12836 (2028)' }];
+    const layers = filterLayers(
+      mockUrlRequest('/foo/bar,js', `?date[after]=${dateAfter}&date[before]=${dateBefore}`),
+      layer,
+    );
+    o(layers).deepEquals(layer);
+  });
+});

package/src/util/config.loader.ts

@@ -15,8 +15,7 @@ export class ConfigLoader {
     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;
+      if (cb) config.assets = cb.assets;
     }
     return config;
   }

package/src/util/filter.ts

@@ -0,0 +1,60 @@
+import { ConfigLayer } from '@basemaps/config';
+import { extractYearRangeFromTitle } from '@basemaps/shared';
+import { LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+
+export const FilterNames = {
+  DateBefore: 'date[before]',
+  DateAfter: 'date[after]',
+};
+
+export function getFilters(req: LambdaHttpRequest): Record<string, string | undefined> {
+  return {
+    [FilterNames.DateBefore]: req.query.get(FilterNames.DateBefore) ?? undefined,
+    [FilterNames.DateAfter]: req.query.get(FilterNames.DateAfter) ?? undefined,
+  };
+}
+/**
+ * Convert the year range into full ISO date year range
+ *
+ * Expand to the full year of jan 1st 00:00 -> Dec 31st 23:59
+ */
+export function yearRangeToInterval(x: [number] | [number, number]): [Date, Date] {
+  if (x.length === 1) return [new Date(`${x[0]}-01-01T00:00:00.000Z`), new Date(`${x[0]}-12-31T23:59:59.999Z`)];
+  return [new Date(`${x[0]}-01-01T00:00:00.000Z`), new Date(`${x[1]}-12-31T23:59:59.999Z`)];
+}
+
+function parseDateAsIso(s: string | null): Date | null {
+  if (s == null) return null;
+  const date = new Date(s);
+  if (isNaN(date.getTime())) throw new LambdaHttpResponse(400, `Invalid date format: "${s}"`);
+  return date;
+}
+
+export function filterLayers(req: LambdaHttpRequest, layers: ConfigLayer[]): ConfigLayer[] {
+  const dateAfterQuery = req.query.get(FilterNames.DateAfter);
+  const dateBeforeQuery = req.query.get(FilterNames.DateBefore);
+
+  if (dateAfterQuery == null && dateBeforeQuery == null) return layers;
+  const dateAfter = parseDateAsIso(dateAfterQuery);
+  const dateBefore = parseDateAsIso(dateBeforeQuery);
+
+  const filtered = layers.filter((l) => {
+    if (l.title == null) return false;
+    const yearRange = extractYearRangeFromTitle(l.title);
+    if (yearRange == null) return false;
+
+    const ranges = yearRangeToInterval(yearRange);
+    const startYear = ranges[0];
+    const endYear = ranges[1];
+    return (dateAfter == null || endYear >= dateAfter) && (dateBefore == null || startYear <= dateBefore);
+  });
+
+  // Trace that layers have been filtered
+  req.set('layerFilter', {
+    [FilterNames.DateBefore]: dateBefore?.toISOString(),
+    [FilterNames.DateAfter]: dateAfter?.toISOString(),
+    layerCount: layers.length,
+    filterCount: filtered.length,
+  });
+  return filtered;
+}

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;
   },