@basemaps/lambda-tiler 6.24.2 → 6.27.0

package/src/routes/__test__/wmts.test.ts

@@ -0,0 +1,40 @@
+import { ImageFormat } from '@basemaps/geo';
+import { LogConfig } from '@basemaps/shared';
+import { LambdaHttpRequest, LambdaUrlRequest } from '@linzjs/lambda';
+import { Context } from 'aws-lambda';
+import o from 'ospec';
+import { getImageFormats } from '../tile.wmts.js';
+
+o.spec('GetImageFormats', () => {
+  function newRequest(path: string, query: string): LambdaHttpRequest {
+    return new LambdaUrlRequest(
+      {
+        requestContext: { http: { method: 'GET' } },
+        headers: {},
+        rawPath: path,
+        rawQueryString: query,
+        isBase64Encoded: false,
+      } as any,
+      {} as Context,
+      LogConfig.get(),
+    );
+  }
+
+  o('should parse all formats', () => {
+    const req = newRequest('/v1/blank', 'format=png&format=jpeg');
+    const formats = getImageFormats(req);
+    o(formats).deepEquals([ImageFormat.Png, ImageFormat.Jpeg]);
+  });
+
+  o('should ignore bad formats', () => {
+    const req = newRequest('/v1/blank', 'format=fake&format=mvt');
+    const formats = getImageFormats(req);
+    o(formats).equals(undefined);
+  });
+
+  o('should de-dupe formats', () => {
+    const req = newRequest('/v1/blank', 'format=png&format=jpeg&format=png&format=jpeg&format=png&format=jpeg');
+    const formats = getImageFormats(req);
+    o(formats).deepEquals([ImageFormat.Png, ImageFormat.Jpeg]);
+  });
+});

package/src/routes/health.ts

@@ -1,6 +1,5 @@
-import { GoogleTms, Nztm2000QuadTms } from '@basemaps/geo';
+import { GoogleTms, Nztm2000QuadTms, ImageFormat } from '@basemaps/geo';
 import { TileDataXyz, TileType } from '@basemaps/shared';
-import { ImageFormat } from '@basemaps/tiler';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import * as fs from 'fs';
 import * as path from 'path';
@@ -14,8 +13,8 @@ interface TestTile extends TileDataXyz {
 }
 
 export const TestTiles: TestTile[] = [
-  { type: TileType.Tile, name: 'health', tileMatrix: GoogleTms, ext: ImageFormat.PNG, x: 252, y: 156, z: 8 },
-  { type: TileType.Tile, name: 'health', tileMatrix: Nztm2000QuadTms, ext: ImageFormat.PNG, x: 30, y: 33, z: 6 },
+  { type: TileType.Tile, name: 'health', tileMatrix: GoogleTms, ext: ImageFormat.Png, x: 252, y: 156, z: 8 },
+  { type: TileType.Tile, name: 'health', tileMatrix: Nztm2000QuadTms, ext: ImageFormat.Png, x: 30, y: 33, z: 6 },
 ];
 const TileSize = 256;
 

package/src/routes/tile.json.ts

@@ -1,43 +1,42 @@
-import { Env } from '@basemaps/shared';
+import { GoogleTms, TileJson, TileMatrixSet } from '@basemaps/geo';
+import { Env, extractTileMatrixSet } from '@basemaps/shared';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
-import { createHash } from 'crypto';
 import { Router } from '../router.js';
-import { NotModified } from './response.js';
-import { TileEtag } from './tile.etag.js';
-
-export interface TileJson {
-  tiles: string[];
-  minzoom: number;
-  maxzoom: number;
-  format: string;
-  tilejson: string;
-}
+import { TileSets } from '../tile.set.cache.js';
+import { getTileMatrixId } from '../wmts.capability.js';
+import { NotFound } from './response.js';
 
 export async function tileJson(req: LambdaHttpRequest): Promise<LambdaHttpResponse> {
   const { version, rest, name } = Router.action(req);
+  if (rest.length !== 3) return NotFound;
+
+  const tileMatrix = extractTileMatrixSet(rest[1]);
+  if (tileMatrix == null) return NotFound;
+
+  req.timer.start('tileset:load');
+  const tileSet = await TileSets.get(rest[0], tileMatrix);
+  req.timer.end('tileset:load');
+  if (tileSet == null) return NotFound;
+
   const apiKey = Router.apiKey(req);
   const host = Env.get(Env.PublicUrlBase) ?? '';
-  const tileUrl = `${host}/${version}/${name}/${rest[0]}/${rest[1]}/{z}/{x}/{y}.pbf?api=${apiKey}`;
 
-  const tileJson: TileJson = {
-    tiles: [tileUrl],
-    minzoom: 0,
-    maxzoom: 15,
-    format: 'pbf',
-    tilejson: '2.0.0',
-  };
+  const tileUrl =
+    [host, version, name, tileSet.fullName, getTileMatrixId(tileMatrix), '{z}', '{x}', '{y}'].join('/') +
+    `.${tileSet.format}?api=${apiKey}`;
 
-  const json = JSON.stringify(tileJson);
+  const tileJson: TileJson = { tiles: [tileUrl], tilejson: '3.0.0' };
+  const maxZoom = TileMatrixSet.convertZoomLevel(tileSet.tileSet.maxZoom ?? 30, GoogleTms, tileMatrix, true);
+  const minZoom = TileMatrixSet.convertZoomLevel(tileSet.tileSet.minZoom ?? 0, GoogleTms, tileMatrix, true);
 
-  const data = Buffer.from(json);
-
-  const cacheKey = createHash('sha256').update(data).digest('base64');
+  if (tileSet.tileSet.maxZoom) tileJson.maxzoom = maxZoom;
+  if (tileSet.tileSet.minZoom) tileJson.minzoom = minZoom;
 
-  if (TileEtag.isNotModified(req, cacheKey)) return NotModified;
+  const json = JSON.stringify(tileJson);
+  const data = Buffer.from(json);
 
   const response = new LambdaHttpResponse(200, 'ok');
-  response.header(HttpHeader.ETag, cacheKey);
-  response.header(HttpHeader.CacheControl, 'max-age=120');
+  response.header(HttpHeader.CacheControl, 'no-store');
   response.buffer(data, 'application/json');
   req.set('bytes', data.byteLength);
   return response;

package/src/routes/tile.wmts.ts

@@ -1,6 +1,7 @@
 import { Config, TileSetType } from '@basemaps/config';
-import { TileMatrixSet } from '@basemaps/geo';
+import { ImageFormat, TileMatrixSet } from '@basemaps/geo';
 import { Env, TileSetName, tileWmtsFromPath } from '@basemaps/shared';
+import { getImageFormat } from '@basemaps/tiler';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import { createHash } from 'crypto';
 import { Router } from '../router.js';
@@ -10,6 +11,20 @@ import { WmtsCapabilities } from '../wmts.capability.js';
 import { NotFound, NotModified } from './response.js';
 import { TileEtag } from './tile.etag.js';
 
+export function getImageFormats(req: LambdaHttpRequest): ImageFormat[] | undefined {
+  const formats = req.query.getAll('format');
+  if (formats == null || formats.length === 0) return undefined;
+
+  const output: Set<ImageFormat> = new Set();
+  for (const fmt of formats) {
+    const parsed = getImageFormat(fmt);
+    if (parsed == null) continue;
+    output.add(parsed);
+  }
+  if (output.size === 0) return undefined;
+  return [...output.values()];
+}
+
 /**
  * Serve a WMTS request
  *
@@ -32,7 +47,13 @@ export async function wmts(req: LambdaHttpRequest): Promise<LambdaHttpResponse>
   if (provider == null) return NotFound;
 
   const apiKey = Router.apiKey(req);
-  const xml = WmtsCapabilities.toXml(host, provider, tileSets, apiKey);
+  const xml = new WmtsCapabilities({
+    httpBase: host,
+    provider,
+    layers: tileSets,
+    apiKey,
+    formats: getImageFormats(req),
+  }).toXml();
   if (xml == null) return NotFound;
 
   const data = Buffer.from(xml);

package/src/tile.set.cache.ts

@@ -63,7 +63,7 @@ export class TileSetCache {
 
     // If we already have a copy and it hasn't been modified just return it
     const existing = this.tileSets.get(tileSetId);
-    if (existing?.tileSet.updatedAt === tileSet.updatedAt) {
+    if (existing != null && existing?.tileSet.updatedAt === tileSet.updatedAt) {
       return existing;
     }
 
@@ -75,7 +75,7 @@ export class TileSetCache {
     }
 
     const ts = new TileSetVector(name, tileMatrix);
-    ts.tileSet = tileSet;
+    await ts.init(tileSet);
     this.tileSets.set(tileSetId, ts);
     return ts;
   }

package/src/tile.set.raster.ts

@@ -6,8 +6,8 @@ import {
   TileSetNameParser,
   TileSetType,
 } from '@basemaps/config';
-import { Bounds, Epsg, Tile, TileMatrixSet, TileMatrixSets } from '@basemaps/geo';
-import { Config, Env, fsa, LogType, TileDataXyz, titleizeImageryName, VectorFormat } from '@basemaps/shared';
+import { Bounds, Epsg, ImageFormat, Tile, TileMatrixSet, TileMatrixSets, VectorFormat } from '@basemaps/geo';
+import { Config, Env, fsa, LogType, TileDataXyz, titleizeImageryName } from '@basemaps/shared';
 import { Tiler } from '@basemaps/tiler';
 import { TileMakerSharp } from '@basemaps/tiler-sharp';
 import { CogTiff } from '@cogeotiff/core';
@@ -20,7 +20,7 @@ import { St } from './source.tracer.js';
 import { TiffCache } from './tiff.cache.js';
 import { TileSets } from './tile.set.cache.js';
 
-const LoadingQueue = pLimit(Env.getNumber(Env.TiffConcurrency, 5));
+const LoadingQueue = pLimit(Env.getNumber(Env.TiffConcurrency, 25));
 
 export const TileComposer = new TileMakerSharp(256);
 
@@ -83,6 +83,11 @@ export class TileSetRaster {
     return this.extentOverride ?? this.tileMatrix.extent;
   }
 
+  /** Preferred default imagery format */
+  get format(): ImageFormat {
+    return this.tileSet.format ?? ImageFormat.Webp;
+  }
+
   async init(record: ConfigTileSetRaster): Promise<void> {
     this.tileSet = record;
     this.imagery = await Config.getAllImagery(this.tileSet.layers, this.tileMatrix.projection);
@@ -160,7 +165,6 @@ export class TileSetRaster {
 
       const imagery = this.imagery.get(imgId);
       if (imagery == null) {
-        console.log('Failed', { imagery, i: this.imagery, ts: this.tileSet.layers });
         log?.warn(
           { layer: layer.name, projection: this.tileMatrix.projection.code, imgId },
           'Failed to lookup imagery',

package/src/tile.set.vector.ts

@@ -1,6 +1,6 @@
 import { ConfigTileSetVector, TileSetNameComponents, TileSetNameParser, TileSetType } from '@basemaps/config';
-import { TileMatrixSet } from '@basemaps/geo';
-import { fsa, TileDataXyz, VectorFormat } from '@basemaps/shared';
+import { GoogleTms, TileMatrixSet, VectorFormat } from '@basemaps/geo';
+import { fsa, TileDataXyz } from '@basemaps/shared';
 import { Cotar } from '@cotar/core';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import { NotFound } from './routes/response.js';
@@ -34,6 +34,15 @@ export class TileSetVector {
     this.tileMatrix = tileMatrix;
   }
 
+  async init(record: ConfigTileSetVector): Promise<void> {
+    this.tileSet = record;
+  }
+
+  /** What format does tile set use */
+  get format(): VectorFormat {
+    return VectorFormat.MapboxVectorTiles;
+  }
+
   get id(): string {
     return TileSets.id(this.fullName, this.tileMatrix);
   }
@@ -44,6 +53,7 @@ export class TileSetVector {
 
   async tile(req: LambdaHttpRequest, xyz: TileDataXyz): Promise<LambdaHttpResponse> {
     if (xyz.ext !== VectorFormat.MapboxVectorTiles) return NotFound;
+    if (xyz.tileMatrix.identifier !== GoogleTms.identifier) return NotFound;
     if (this.tileSet.layers.length > 1) return new LambdaHttpResponse(500, 'Too many layers in tileset');
     const [layer] = this.tileSet.layers;
     if (layer[3857] == null) return new LambdaHttpResponse(500, 'Layer url not found from tileset Config');

package/src/wmts.capability.ts

@@ -1,5 +1,4 @@
-import { ConfigProvider } from '@basemaps/config';
-import { Bounds, Nztm2000QuadTms, TileMatrixSet, WmtsProvider } from '@basemaps/geo';
+import { Bounds, ImageFormat, Nztm2000QuadTms, TileMatrixSet, WmtsProvider } from '@basemaps/geo';
 import { Projection, V, VNodeElement } from '@basemaps/shared';
 import { ImageFormatOrder } from '@basemaps/tiler';
 import { BBox, Wgs84 } from '@linzjs/geojson';
@@ -23,12 +22,20 @@ function wgs84Extent(layer: TileSetRaster): BBox {
 /**
  * Default the tile matrix id to the projection of the TileMatrixSet
  */
-function getTileMatrixId(tileMatrix: TileMatrixSet): string {
+export function getTileMatrixId(tileMatrix: TileMatrixSet): string {
   // TODO this should really change everything to identifier
   if (tileMatrix.identifier === Nztm2000QuadTms.identifier) return Nztm2000QuadTms.identifier;
   return tileMatrix.projection.toEpsgString();
 }
 
+export interface WmtsCapabilitiesParams {
+  httpBase: string;
+  provider: WmtsProvider;
+  layers: TileSetRaster[];
+  apiKey?: string;
+  formats?: ImageFormat[];
+}
+
 export class WmtsCapabilities {
   httpBase: string;
   provider: WmtsProvider;
@@ -37,12 +44,13 @@ export class WmtsCapabilities {
 
   apiKey?: string;
   tileMatrixSets = new Map<string, TileMatrixSet>();
+  formats: ImageFormat[];
 
-  constructor(httpBase: string, provider: WmtsProvider, layers: TileSetRaster[], apiKey?: string) {
-    this.httpBase = httpBase;
-    this.provider = provider;
+  constructor(params: WmtsCapabilitiesParams) {
+    this.httpBase = params.httpBase;
+    this.provider = params.provider;
 
-    for (const layer of layers) {
+    for (const layer of params.layers) {
       // TODO is grouping by name the best option
       let existing = this.layers.get(layer.fullName);
       if (existing == null) {
@@ -54,7 +62,8 @@ export class WmtsCapabilities {
 
       this.tileMatrixSets.set(layer.tileMatrix.identifier, layer.tileMatrix);
     }
-    this.apiKey = apiKey;
+    this.apiKey = params.apiKey;
+    this.formats = params.formats ?? ImageFormatOrder;
   }
 
   buildWgs84BoundingBox(layers: TileSetRaster[], tagName = 'ows:WGS84BoundingBox'): VNodeElement {
@@ -153,9 +162,9 @@ export class WmtsCapabilities {
       ...layers.map((layer) => this.buildBoundingBox(layer.tileMatrix, layer.extent)),
       this.buildWgs84BoundingBox(layers),
       this.buildStyle(),
-      ...ImageFormatOrder.map((fmt) => V('Format', 'image/' + fmt)),
+      ...this.formats.map((fmt) => V('Format', 'image/' + fmt)),
       ...matrixSetNodes,
-      ...ImageFormatOrder.map((fmt) => this.buildResourceUrl(firstLayer, fmt)),
+      ...this.formats.map((fmt) => this.buildResourceUrl(firstLayer, fmt)),
     ]);
   }
 
@@ -193,11 +202,7 @@ export class WmtsCapabilities {
     return V('Capabilities', CapabilitiesAttrs, [...this.buildProvider(), V('Contents', layers)]);
   }
 
-  toString(): string {
+  toXml(): string {
     return '<?xml version="1.0"?>\n' + this.toVNode().toString();
   }
-
-  static toXml(httpBase: string, provider: ConfigProvider, tileSet: TileSetRaster[], apiKey?: string): string {
-    return new WmtsCapabilities(httpBase, provider, tileSet, apiKey).toString();
-  }
 }