@basemaps/lambda-tiler 6.39.0 → 6.40.0

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: {
@@ -59,11 +60,12 @@ export async function wmtsCapabilitiesGet(req: LambdaHttpRequest<WmtsCapabilitie
     provider: provider ?? undefined,
     tileSet,
     tileMatrix,
-    isIndividualLayers: req.params.tileMatrix == null,
     imagery,
     apiKey,
     config: ConfigLoader.extract(req),
     formats: Validate.getRequestedFormats(req),
+    layers: req.params.tileMatrix == null ? filterLayers(req, tileSet.layers) : null,
+    filters: getFilters(req),
   }).toXml();
   if (xml == null) return NotFound();
 

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/wmts.capability.ts

@@ -28,8 +28,6 @@ export interface WmtsCapabilitiesParams {
   tileSet: ConfigTileSet;
   /** List of tile matrixes to output */
   tileMatrix: TileMatrixSet[];
-  /** Should WMTS Layers be created for each imagery set inside this tileSet */
-  isIndividualLayers: boolean;
   /** All the imagery used by the tileSet and tileMatrixes */
   imagery: Map<string, ConfigImagery>;
   /** API key to append to all resource urls */
@@ -38,6 +36,10 @@ export interface WmtsCapabilitiesParams {
   formats?: ImageFormat[] | null;
   /** Config location */
   config?: string | null;
+  /** Specific layers to add to the WMTS */
+  layers?: ConfigLayer[] | null;
+  /** Specific DateRange filter for the wmts layers */
+  filters?: Record<string, string | undefined>;
 }
 
 /** Number of decimal places to use in lat lng */
@@ -62,21 +64,23 @@ export class WmtsCapabilities {
   tileMatrixSets = new Map<string, TileMatrixSet>();
   imagery: Map<string, ConfigImagery>;
   formats: ImageFormat[];
-  isIndividualLayers = false;
+  filters?: Record<string, string | undefined>;
 
   minZoom = 0;
   maxZoom = 32;
+  layers: ConfigLayer[] | null | undefined;
 
   constructor(params: WmtsCapabilitiesParams) {
     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;
     this.formats = params.formats ?? ImageFormatOrder;
     this.imagery = params.imagery;
+    this.layers = params.layers;
+    this.filters = params.filters;
   }
 
   buildWgs84BoundingBox(tms: TileMatrixSet, layers: Bounds[]): VNodeElement {
@@ -159,8 +163,9 @@ export class WmtsCapabilities {
     ];
   }
 
-  buildTileUrl(tileSetId: string, suffix: string): string {
-    const query = toQueryString({ api: this.apiKey, config: this.config });
+  buildTileUrl(tileSetId: string, suffix: string, addFilter = false): string {
+    let query = { api: this.apiKey, config: this.config };
+    if (addFilter) query = { api: this.apiKey, config: this.config, ...this.filters };
 
     return [
       this.httpBase,
@@ -170,15 +175,15 @@ export class WmtsCapabilities {
       '{TileMatrixSet}',
       '{TileMatrix}',
       '{TileCol}',
-      `{TileRow}.${suffix}${query}`,
+      `{TileRow}.${suffix}${toQueryString(query)}`,
     ].join('/');
   }
 
-  buildResourceUrl(tileSetId: string, suffix: string): VNodeElement {
+  buildResourceUrl(tileSetId: string, suffix: string, addFilter = false): VNodeElement {
     return V('ResourceURL', {
       format: 'image/' + suffix,
       resourceType: 'tile',
-      template: this.buildTileUrl(tileSetId, suffix),
+      template: this.buildTileUrl(tileSetId, suffix, addFilter),
     });
   }
 
@@ -202,7 +207,7 @@ export class WmtsCapabilities {
     if (firstImg == null) return null;
 
     return V('Layer', [
-      V('ows:Title', layer.title ?? layerNameId),
+      V('ows:Title', layer.title),
       V('ows:Abstract', ''),
       V('ows:Identifier', layerNameId),
       this.buildKeywords(firstImg),
@@ -241,7 +246,7 @@ export class WmtsCapabilities {
     }
 
     return V('Layer', [
-      V('ows:Title', layer.title ?? layerNameId),
+      V('ows:Title', layer.title),
       V('ows:Abstract', layer.description ?? ''),
       V('ows:Identifier', layerNameId),
       this.buildKeywords(layer),
@@ -250,7 +255,7 @@ export class WmtsCapabilities {
       this.buildStyle(),
       ...this.formats.map((fmt) => V('Format', 'image/' + fmt)),
       ...matrixSetNodes,
-      ...this.formats.map((fmt) => this.buildResourceUrl(layerNameId, fmt)),
+      ...this.formats.map((fmt) => this.buildResourceUrl(layerNameId, fmt, true)),
     ]);
   }
 
@@ -287,10 +292,10 @@ export class WmtsCapabilities {
     const layers: (VNodeElement | null)[] = [];
     layers.push(this.buildLayer(this.tileSet));
 
-    if (this.isIndividualLayers) {
+    if (this.layers) {
       const layerByName = new Map<string, ConfigLayer>();
       // Dedupe the layers by unique name
-      for (const img of this.tileSet.layers) layerByName.set(standardizeLayerName(img.name), img);
+      for (const img of this.layers) layerByName.set(standardizeLayerName(img.name), img);
       const orderedLayers = Array.from(layerByName.values()).sort((a, b) =>
         (a.title ?? a.name).localeCompare(b.title ?? b.name),
       );