@basemaps/lambda-tiler 6.18.0 → 6.21.1

package/src/routes/tile.wmts.ts

@@ -0,0 +1,59 @@
+import { Config, TileSetType } from '@basemaps/config';
+import { TileMatrixSet } from '@basemaps/geo';
+import { Env, TileSetName, tileWmtsFromPath } from '@basemaps/shared';
+import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import { createHash } from 'crypto';
+import { Router } from '../router.js';
+import { TileSets } from '../tile.set.cache.js';
+import { TileSetRaster } from '../tile.set.raster.js';
+import { WmtsCapabilities } from '../wmts.capability.js';
+import { NotFound, NotModified } from './response.js';
+import { TileEtag } from './tile.etag.js';
+
+/**
+ * Serve a WMTS request
+ *
+ * /v1/tiles/:tileSet/:tileMatrixSet/WMTSCapabilities.xml
+ * @example `/v1/tiles/aerial/NZTM2000Quad/WMTSCapabilities.xml`
+ */
+export async function wmts(req: LambdaHttpRequest): Promise<LambdaHttpResponse> {
+  const action = Router.action(req);
+  const wmtsData = tileWmtsFromPath(action.rest);
+  if (wmtsData == null) return NotFound;
+  const host = Env.get(Env.PublicUrlBase) ?? '';
+
+  req.timer.start('tileset:load');
+  const tileSets = await wmtsLoadTileSets(wmtsData.name, wmtsData.tileMatrix);
+  req.timer.end('tileset:load');
+  if (tileSets.length === 0) return NotFound;
+
+  const providerId = Config.Provider.id('linz');
+  const provider = await Config.Provider.get(providerId);
+  if (provider == null) return NotFound;
+
+  const apiKey = Router.apiKey(req);
+  const xml = WmtsCapabilities.toXml(host, provider, tileSets, apiKey);
+  if (xml == null) return NotFound;
+
+  const data = Buffer.from(xml);
+
+  const cacheKey = createHash('sha256').update(data).digest('base64');
+  if (TileEtag.isNotModified(req, cacheKey)) return NotModified;
+
+  const response = new LambdaHttpResponse(200, 'ok');
+  response.header(HttpHeader.ETag, cacheKey);
+  response.header(HttpHeader.CacheControl, 'max-age=0');
+  response.buffer(data, 'text/xml');
+  req.set('bytes', data.byteLength);
+  return response;
+}
+
+async function wmtsLoadTileSets(name: string, tileMatrix: TileMatrixSet | null): Promise<TileSetRaster[]> {
+  if (tileMatrix != null) {
+    const ts = await TileSets.get(name, tileMatrix);
+    if (ts == null || ts.type === TileSetType.Vector) return [];
+    return [ts];
+  }
+  if (name === '') name = TileSetName.aerial;
+  return (await TileSets.getAll(name, tileMatrix)).filter((f) => f.type === 'raster') as TileSetRaster[];
+}

package/src/routes/tile.xyz.ts

@@ -0,0 +1,30 @@
+import { tileXyzFromPath } from '@basemaps/shared';
+import { LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import { Router } from '../router.js';
+import { TileSets } from '../tile.set.cache.js';
+import { ValidateTilePath } from '../validate.js';
+import { NotFound } from './response.js';
+
+/**
+ * Serve a tile
+ *
+ * /v1/tiles/:tileSet/:tileMatrixSet/:z/:x/:y.:tileType
+ *
+ * @example
+ *  Vector Tile `/v1/tiles/topographic/EPSG:3857/2/1/1.pbf`
+ *  Raster Tile `/v1/tiles/aerial/EPSG:3857/6/0/38.webp`
+ * @returns
+ */
+export async function tileXyz(req: LambdaHttpRequest): Promise<LambdaHttpResponse> {
+  const action = Router.action(req);
+  const xyzData = tileXyzFromPath(action.rest);
+  if (xyzData == null) return NotFound;
+  ValidateTilePath.validate(req, xyzData);
+
+  req.timer.start('tileset:load');
+  const tileSet = await TileSets.get(xyzData.name, xyzData.tileMatrix);
+  req.timer.end('tileset:load');
+  if (tileSet == null) return NotFound;
+
+  return await tileSet.tile(req, xyzData);
+}

package/src/source.tracer.ts

@@ -0,0 +1,34 @@
+import { ChunkSource } from '@chunkd/core';
+
+interface SourceRequest {
+  offset: number;
+  length?: number;
+  source: string;
+  duration?: number;
+}
+
+export class SourceTracer {
+  requests: SourceRequest[] = [];
+
+  /** Reset the request tracer */
+  reset(): void {
+    this.requests = [];
+  }
+
+  /** Override the fetchByte function to trace all requests for this source  */
+  trace(source: ChunkSource): void {
+    const originFetch = source.fetchBytes;
+    source.fetchBytes = async (offset: number, length?: number): Promise<ArrayBuffer> => {
+      const request: SourceRequest = { source: source.uri, offset, length };
+      this.requests.push(request);
+      const startTime = Date.now();
+
+      const ret = await originFetch.apply(source, [offset, length]);
+
+      request.duration = Date.now() - startTime;
+      return ret;
+    };
+  }
+}
+
+export const St = new SourceTracer();

package/src/tile.set.cache.ts

@@ -1,4 +1,4 @@
-import { TileSetNameParser } from '@basemaps/config';
+import { TileSetNameParser, TileSetType } from '@basemaps/config';
 import { TileMatrixSet, TileMatrixSets } from '@basemaps/geo';
 import { Config } from '@basemaps/shared';
 import { TileSet } from './tile.set.js';
@@ -50,7 +50,7 @@ export class TileSetCache {
     if (nameComp.layer != null) {
       const parentName = TileSetNameParser.componentsToName({ ...nameComp, layer: undefined });
       const parent = await this.get(parentName, tileMatrix);
-      if (parent == null || parent.isVector()) return null;
+      if (parent == null || parent.type === TileSetType.Vector) return null;
       return parent.child(nameComp.layer);
     }
 
@@ -91,7 +91,7 @@ export class TileSetCache {
     const tileSets: TileSetRaster[] = [];
     for (const parent of tileMatrixSets) {
       if (parent == null) continue;
-      if (parent.isVector()) continue;
+      if (parent.type === TileSetType.Vector) continue;
 
       tileSets.push(parent);
       if (nameComp.layer != null) {

package/src/tile.set.raster.ts

@@ -1,18 +1,29 @@
-import { ConfigImagery, ConfigLayer, ConfigTileSetRaster, TileSetNameParser, TileSetType } from '@basemaps/config';
+import {
+  ConfigImagery,
+  ConfigLayer,
+  ConfigTileSetRaster,
+  TileSetNameComponents,
+  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 { Tiler } from '@basemaps/tiler';
+import { TileMakerSharp } from '@basemaps/tiler-sharp';
 import { CogTiff } from '@cogeotiff/core';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import { Metrics } from '@linzjs/metrics';
 import pLimit from 'p-limit';
+import { NotFound, NotModified } from './routes/response.js';
 import { TileEtag } from './routes/tile.etag.js';
-import { NotFound, NotModified, TileComposer } from './routes/tile.js';
+import { St } from './source.tracer.js';
 import { TiffCache } from './tiff.cache.js';
-import { TileSetHandler } from './tile.set.js';
+import { TileSets } from './tile.set.cache.js';
 
 const LoadingQueue = pLimit(Env.getNumber(Env.TiffConcurrency, 5));
 
+export const TileComposer = new TileMakerSharp(256);
+
 export interface TileSetResponse {
   buffer: Buffer;
   metrics: Metrics;
@@ -24,14 +35,17 @@ export interface TileSetResponse {
 const DefaultResizeKernel = { in: 'lanczos3', out: 'lanczos3' } as const;
 const DefaultBackground = { r: 0, g: 0, b: 0, alpha: 0 };
 
-export class TileSetRaster extends TileSetHandler<ConfigTileSetRaster> {
-  type = TileSetType.Raster;
+export class TileSetRaster {
+  type: TileSetType.Raster = TileSetType.Raster;
 
   tileMatrix: TileMatrixSet;
   tiler: Tiler;
   imagery: Map<string, ConfigImagery>;
   extentOverride: Bounds;
 
+  components: TileSetNameComponents;
+  tileSet: ConfigTileSetRaster;
+
   /**
    * Return the location of a imagery `record`
    * @param record
@@ -44,10 +58,19 @@ export class TileSetRaster extends TileSetHandler<ConfigTileSetRaster> {
   }
 
   constructor(name: string, tileMatrix: TileMatrixSet) {
-    super(name, tileMatrix);
+    this.components = TileSetNameParser.parse(name);
+    this.tileMatrix = tileMatrix;
     this.tiler = new Tiler(this.tileMatrix);
   }
 
+  get id(): string {
+    return TileSets.id(this.fullName, this.tileMatrix);
+  }
+
+  get fullName(): string {
+    return TileSetNameParser.componentsToName(this.components);
+  }
+
   get title(): string {
     return this.tileSet?.title ?? this.components.name;
   }
@@ -129,7 +152,7 @@ export class TileSetRaster extends TileSetHandler<ConfigTileSetRaster> {
       if (layer.maxZoom != null && filterZoom > layer.maxZoom) continue;
       if (layer.minZoom != null && filterZoom < layer.minZoom) continue;
 
-      const imgId = Config.getImageId(layer, this.tileMatrix.projection);
+      const imgId = layer[this.tileMatrix.projection.code];
       if (imgId == null) {
         log?.warn({ layer: layer.name, projection: this.tileMatrix.projection.code }, 'Failed to lookup imagery');
         continue;
@@ -163,6 +186,8 @@ export class TileSetRaster extends TileSetHandler<ConfigTileSetRaster> {
         if (source == null) {
           throw new Error(`Failed to create CogSource from  ${TileSetRaster.basePath(record, c.name)}`);
         }
+
+        St.trace(source);
         existing = new CogTiff(source);
         TiffCache.set(tiffKey, existing);
       }

package/src/tile.set.ts

@@ -1,44 +1,4 @@
-import {
-  ConfigTileSetRaster,
-  ConfigTileSetVector,
-  TileSetNameComponents,
-  TileSetNameParser,
-  TileSetType,
-} from '@basemaps/config';
-import { TileMatrixSet } from '@basemaps/geo';
-import { LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
-import { TileDataXyz } from '@basemaps/shared';
-import { TileSets } from './tile.set.cache.js';
 import { TileSetRaster } from './tile.set.raster.js';
 import { TileSetVector } from './tile.set.vector.js';
 
 export type TileSet = TileSetVector | TileSetRaster;
-
-export abstract class TileSetHandler<T extends ConfigTileSetRaster | ConfigTileSetVector> {
-  type: TileSetType;
-  components: TileSetNameComponents;
-  tileMatrix: TileMatrixSet;
-  tileSet: T;
-  constructor(name: string, tileMatrix: TileMatrixSet) {
-    this.components = TileSetNameParser.parse(name);
-    this.tileMatrix = tileMatrix;
-  }
-
-  get id(): string {
-    return TileSets.id(this.fullName, this.tileMatrix);
-  }
-
-  get fullName(): string {
-    return TileSetNameParser.componentsToName(this.components);
-  }
-
-  isVector(): this is TileSetVector {
-    return this.type === TileSetType.Vector;
-  }
-
-  isRaster(): this is TileSetRaster {
-    return this.type === TileSetType.Raster;
-  }
-
-  abstract tile(req: LambdaHttpRequest, xyz: TileDataXyz): Promise<LambdaHttpResponse>;
-}

package/src/tile.set.vector.ts

@@ -1,9 +1,11 @@
-import { ConfigTileSetVector, TileSetType } from '@basemaps/config';
+import { ConfigTileSetVector, TileSetNameComponents, TileSetNameParser, TileSetType } from '@basemaps/config';
+import { TileMatrixSet } from '@basemaps/geo';
 import { fsa, TileDataXyz, VectorFormat } from '@basemaps/shared';
 import { Cotar } from '@cotar/core';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
-import { NotFound } from './routes/tile.js';
-import { TileSetHandler } from './tile.set.js';
+import { NotFound } from './routes/response.js';
+import { TileSets } from './tile.set.cache.js';
+import { St } from './source.tracer.js';
 
 class CotarCache {
   cache = new Map<string, Promise<Cotar | null>>();
@@ -11,7 +13,9 @@ class CotarCache {
   get(uri: string): Promise<Cotar | null> {
     let cotar = this.cache.get(uri);
     if (cotar == null) {
-      cotar = Cotar.fromTar(fsa.source(uri));
+      const source = fsa.source(uri);
+      St.trace(source);
+      cotar = Cotar.fromTar(source);
       this.cache.set(uri, cotar);
     }
     return cotar;
@@ -20,8 +24,23 @@ class CotarCache {
 
 export const Layers = new CotarCache();
 
-export class TileSetVector extends TileSetHandler<ConfigTileSetVector> {
-  type = TileSetType.Vector;
+export class TileSetVector {
+  type: TileSetType.Vector = TileSetType.Vector;
+  components: TileSetNameComponents;
+  tileMatrix: TileMatrixSet;
+  tileSet: ConfigTileSetVector;
+  constructor(name: string, tileMatrix: TileMatrixSet) {
+    this.components = TileSetNameParser.parse(name);
+    this.tileMatrix = tileMatrix;
+  }
+
+  get id(): string {
+    return TileSets.id(this.fullName, this.tileMatrix);
+  }
+
+  get fullName(): string {
+    return TileSetNameParser.componentsToName(this.components);
+  }
 
   async tile(req: LambdaHttpRequest, xyz: TileDataXyz): Promise<LambdaHttpResponse> {
     if (xyz.ext !== VectorFormat.MapboxVectorTiles) return NotFound;
@@ -38,7 +57,7 @@ export class TileSetVector extends TileSetHandler<ConfigTileSetVector> {
     const y = (1 << xyz.z) - 1 - xyz.y;
 
     req.timer.start('cotar:tile');
-    const tile = await cotar.get(`tiles/${xyz.z}/${xyz.x}/${y}.pbf.gz`, req.log);
+    const tile = await cotar.get(`tiles/${xyz.z}/${xyz.x}/${y}.pbf.gz`);
     if (tile == null) return NotFound;
     req.timer.end('cotar:tile');