@basemaps/lambda-tiler 6.28.1 → 6.31.0

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

@@ -1,25 +1,29 @@
 import { ImageFormat } from '@basemaps/geo';
-import { LogConfig } from '@basemaps/shared';
+import { Config, LogConfig } from '@basemaps/shared';
 import { LambdaHttpRequest, LambdaUrlRequest } from '@linzjs/lambda';
 import { Context } from 'aws-lambda';
 import o from 'ospec';
+import { handleRequest } from '../../index.js';
+import { ulid } from 'ulid';
 import { getImageFormats } from '../tile.wmts.js';
+import { createSandbox } from 'sinon';
+import { Imagery2193, Imagery3857, Provider, TileSetAerial } from '../../__tests__/config.data.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(),
-    );
-  }
+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.spec('GetImageFormats', () => {
   o('should parse all formats', () => {
     const req = newRequest('/v1/blank', 'format=png&format=jpeg');
     const formats = getImageFormats(req);
@@ -37,4 +41,60 @@ o.spec('GetImageFormats', () => {
     const formats = getImageFormats(req);
     o(formats).deepEquals([ImageFormat.Png, ImageFormat.Jpeg]);
   });
+
+  o('should support "tileFormat" Alias all formats', () => {
+    const req = newRequest('/v1/blank', 'tileFormat=png&format=jpeg');
+    const formats = getImageFormats(req);
+    o(formats).deepEquals([ImageFormat.Jpeg, ImageFormat.Png]);
+  });
+
+  o('should not duplicate "tileFormat" alias all formats', () => {
+    const req = newRequest('/v1/blank', 'tileFormat=jpeg&format=jpeg');
+    const formats = getImageFormats(req);
+    o(formats).deepEquals([ImageFormat.Jpeg]);
+  });
+});
+
+o.spec('WMTSRouting', () => {
+  const sandbox = createSandbox();
+  o.afterEach(() => {
+    sandbox.restore();
+  });
+
+  o('should default to the aerial layer', async () => {
+    const imagery = new Map();
+    imagery.set(Imagery3857.id, Imagery3857);
+    imagery.set(Imagery2193.id, Imagery2193);
+
+    const tileSetStub = sandbox.stub(Config.TileSet, 'get').returns(Promise.resolve(TileSetAerial));
+    const imageryStub = sandbox.stub(Config.Imagery, 'getAll').returns(Promise.resolve(imagery));
+    const providerStub = sandbox.stub(Config.Provider, 'get').returns(Promise.resolve(Provider));
+
+    const req = newRequest('/v1/tiles/WMTSCapabilities.xml', 'format=png&api=c' + ulid());
+    const res = await handleRequest(req);
+
+    o(tileSetStub.calledOnce).equals(true);
+    o(tileSetStub.args[0][0]).equals('ts_aerial');
+
+    o(providerStub.calledOnce).equals(true);
+    o(providerStub.args[0][0]).equals('pv_linz');
+
+    o(imageryStub.calledOnce).equals(true);
+    o([...imageryStub.args[0][0].values()]).deepEquals([
+      'im_01FYWKATAEK2ZTJQ2PX44Y0XNT',
+      'im_01FYWKAJ86W9P7RWM1VB62KD0H',
+    ]);
+
+    o(res.status).equals(200);
+    const lines = Buffer.from(res.body, 'base64').toString().split('\n');
+
+    const titles = lines.filter((f) => f.startsWith('      <ows:Title>')).map((f) => f.trim());
+
+    o(titles).deepEquals([
+      '<ows:Title>Aerial Imagery</ows:Title>',
+      '<ows:Title>Ōtorohanga 0.1m Urban Aerial Photos (2021)</ows:Title>',
+      '<ows:Title>Google Maps Compatible for the World</ows:Title>',
+      '<ows:Title>LINZ NZTM2000 Map Tile Grid V2</ows:Title>',
+    ]);
+  });
 });

package/src/routes/api.ts

@@ -3,10 +3,6 @@ import { LambdaHttpResponse, HttpHeader } from '@linzjs/lambda';
 const OkResponse = new LambdaHttpResponse(200, 'ok');
 OkResponse.header(HttpHeader.CacheControl, 'no-store');
 
-export async function Health(): Promise<LambdaHttpResponse> {
-  return OkResponse;
-}
-
 export async function Ping(): Promise<LambdaHttpResponse> {
   return OkResponse;
 }

package/src/routes/attribution.ts

@@ -87,7 +87,6 @@ async function readStac(uri: string): Promise<StacCollection | null> {
 
 export function createAttributionCollection(
   tileSet: TileSetRaster,
-  stac: StacCollection | null | undefined,
   imagery: ConfigImagery,
   layer: ConfigLayer,
   host: ConfigProvider,
@@ -96,16 +95,15 @@ export function createAttributionCollection(
   const tileMatrix = tileSet.tileMatrix;
   return {
     stac_version: Stac.Version,
-    license: stac?.license ?? Stac.License,
+    license: Stac.License,
     id: imagery.id,
-    providers: stac?.providers ?? [
-      { name: host.serviceProvider.name, url: host.serviceProvider.site, roles: ['host'] },
-    ],
-    title: stac?.title ?? titleizeImageryName(imagery.name),
-    description: stac?.description ?? 'No description',
+    providers: [{ name: host.serviceProvider.name, url: host.serviceProvider.site, roles: ['host'] }],
+    title: imagery.title ?? titleizeImageryName(imagery.name),
+    description: 'No description',
     extent,
     links: [],
     summaries: {
+      'linz:category': imagery.category,
       'linz:zoom': {
         min: TileMatrixSet.convertZoomLevel(layer.minZoom ? layer.minZoom : 0, GoogleTms, tileMatrix, true),
         max: TileMatrixSet.convertZoomLevel(layer.maxZoom ? layer.maxZoom : 32, GoogleTms, tileMatrix, true),
@@ -146,18 +144,13 @@ async function tileSetAttribution(tileSet: TileSetRaster): Promise<AttributionSt
     if (imgId == null) continue;
     const im = tileSet.imagery.get(imgId);
     if (im == null) continue;
-    const stac = await stacFiles.get(im.uri);
 
     const bbox = proj.boundsToWgs84BoundingBox(im.bounds).map(roundNumber) as BBox;
 
-    let interval: [string, string][] | undefined = stac?.extent.temporal.interval;
-    if (interval == null) {
-      const years = extractYearRangeFromName(im.name);
-      if (years[0] === -1) {
-        throw new Error('Missing date in imagery name: ' + im.name);
-      }
-      interval = [years.map((y) => `${y}-01-01T00:00:00Z`) as [string, string]];
-    }
+    const years = extractYearRangeFromName(im.name);
+    if (years[0] === -1) throw new Error('Missing date in imagery name: ' + im.name);
+    const interval = [years.map((y) => `${y}-01-01T00:00:00Z`) as [string, string]];
+
     const extent: StacExtent = { spatial: { bbox: [bbox] }, temporal: { interval } };
 
     items.push({
@@ -173,14 +166,15 @@ async function tileSetAttribution(tileSet: TileSetRaster): Promise<AttributionSt
         coordinates: createCoordinates(bbox, im.files, proj),
       },
       properties: {
-        title: titleizeImageryName(im.name),
+        title: im.title ?? titleizeImageryName(im.name),
+        category: im.category,
         datetime: null,
         start_datetime: interval[0][0],
         end_datetime: interval[0][1],
       },
     });
 
-    cols.push(createAttributionCollection(tileSet, stac, im, layer, host, extent));
+    cols.push(createAttributionCollection(tileSet, im, layer, host, extent));
   }
   return {
     id: tileSet.id,

package/src/routes/fonts.ts

@@ -0,0 +1,62 @@
+import { Env } from '@basemaps/shared';
+import { fsa } from '@chunkd/fs';
+import { LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import path from 'path';
+import { serveFromCotar } from '../cotar.cache.js';
+import { NotFound } from './response.js';
+
+interface FontGet {
+  Params: { fontStack: string; range: string };
+}
+
+export async function fontGet(req: LambdaHttpRequest<FontGet>): Promise<LambdaHttpResponse> {
+  const assetLocation = Env.get(Env.AssetLocation);
+  if (assetLocation == null) return NotFound;
+
+  const fontStack = decodeURIComponent(req.params.fontStack);
+  const targetFile = path.join('fonts', fontStack, req.params.range) + '.pbf';
+
+  if (assetLocation.endsWith('.tar.co')) return serveFromCotar(assetLocation, targetFile, 'application/x-protobuf');
+
+  try {
+    const filePath = fsa.join(assetLocation, targetFile);
+    const buf = await fsa.read(filePath);
+
+    return LambdaHttpResponse.ok().buffer(buf, 'application/x-protobuf');
+  } catch (e: any) {
+    if (e.code === 404) return NotFound;
+    throw e;
+  }
+}
+
+/** Get the unique name of folders is a path that contain .pbf files */
+export async function getFonts(fontPath: string): Promise<string[]> {
+  const fonts = new Set<string>();
+
+  // TODO use {recursive: false}
+  for await (const font of fsa.list(fontPath)) {
+    if (!font.endsWith('.pbf')) continue;
+    const dirName = path.basename(path.dirname(font)); // TODO this only works for /a/b.pbf and not /a/b/c.pbf
+    if (dirName.includes('/')) continue;
+    fonts.add(dirName);
+  }
+  // Ensure the fonts are alphabetical
+  return [...fonts].sort();
+}
+
+export async function fontList(): Promise<LambdaHttpResponse> {
+  const assetLocation = Env.get(Env.AssetLocation);
+  if (assetLocation == null) return NotFound;
+
+  if (assetLocation.endsWith('.tar.co')) return serveFromCotar(assetLocation, 'fonts.json', 'application/json');
+
+  try {
+    const filePath = fsa.join(assetLocation, '/fonts');
+    const fonts = await getFonts(filePath);
+
+    return LambdaHttpResponse.ok().buffer(JSON.stringify(fonts), 'application/json');
+  } catch (e: any) {
+    if (e.code === 404) return NotFound;
+    throw e;
+  }
+}

package/src/routes/imagery.ts

@@ -4,7 +4,6 @@ import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambd
 import { createHash } from 'crypto';
 import { promisify } from 'util';
 import { gzip } from 'zlib';
-import { Router } from '../router.js';
 import { NotModified } from './response.js';
 import { TileEtag } from './tile.etag.js';
 
@@ -17,6 +16,10 @@ export function isAllowedFile(f: string): boolean {
   return false;
 }
 
+interface ImageryGet {
+  Params: { imageryId: string; fileName: string };
+}
+
 /**
  * Get metadata around the imagery such as the source bounding box or the bounding box of the COGS
  *
@@ -27,15 +30,14 @@ export function isAllowedFile(f: string): boolean {
  * - /v1/imagery/:imageryId/collection.json - STAC Collection
  * - /v1/imagery/:imageryId/15-32659-21603.json - STAC Item
  */
-export async function Imagery(req: LambdaHttpRequest): Promise<LambdaHttpResponse> {
-  const { rest } = Router.action(req);
-  const [imageryId, requestType] = rest;
-  if (!isAllowedFile(requestType)) return new LambdaHttpResponse(404, 'Not found');
+export async function imageryGet(req: LambdaHttpRequest<ImageryGet>): Promise<LambdaHttpResponse> {
+  const requestedFile = req.params.fileName;
+  if (!isAllowedFile(requestedFile)) return new LambdaHttpResponse(404, 'Not found');
 
-  const imagery = await Config.Imagery.get(Config.Imagery.id(imageryId));
+  const imagery = await Config.Imagery.get(Config.Imagery.id(req.params.imageryId));
   if (imagery == null) return new LambdaHttpResponse(404, 'Not found');
 
-  const targetPath = fsa.join(imagery.uri, requestType);
+  const targetPath = fsa.join(imagery.uri, requestedFile);
 
   try {
     const buf = await fsa.read(targetPath);

package/src/routes/sprites.ts

@@ -0,0 +1,41 @@
+import { Env } from '@basemaps/shared';
+import { fsa } from '@chunkd/fs';
+import path from 'path';
+import { LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import { NotFound } from './response.js';
+import { isGzip, serveFromCotar } from '../cotar.cache.js';
+
+interface SpriteGet {
+  Params: {
+    spriteName: string;
+  };
+}
+
+const Extensions = new Map();
+Extensions.set('.png', 'image/png');
+Extensions.set('.json', 'application/json');
+
+export async function spriteGet(req: LambdaHttpRequest<SpriteGet>): Promise<LambdaHttpResponse> {
+  const assetLocation = Env.get(Env.AssetLocation);
+  if (assetLocation == null) return NotFound;
+
+  const extension = path.extname(req.params.spriteName);
+  const mimeType = Extensions.get(extension);
+  if (mimeType == null) return NotFound;
+
+  const targetFile = fsa.join('sprites', req.params.spriteName);
+  if (assetLocation.endsWith('.tar.co')) return serveFromCotar(assetLocation, targetFile, mimeType);
+
+  try {
+    const filePath = fsa.join(assetLocation, targetFile);
+    req.set('target', filePath);
+
+    const buf = await fsa.read(filePath);
+    const res = LambdaHttpResponse.ok().buffer(buf, mimeType);
+    if (isGzip(buf)) res.header('content-encoding', 'gzip');
+    return res;
+  } catch (e: any) {
+    if (e.code === 404) return NotFound;
+    throw e;
+  }
+}

package/src/routes/tile.json.ts

@@ -3,7 +3,6 @@ import { Env, extractTileMatrixSet } from '@basemaps/shared';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import { Router } from '../router.js';
 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> {
@@ -22,7 +21,7 @@ export async function tileJson(req: LambdaHttpRequest): Promise<LambdaHttpRespon
   const host = Env.get(Env.PublicUrlBase) ?? '';
 
   const tileUrl =
-    [host, version, name, tileSet.fullName, getTileMatrixId(tileMatrix), '{z}', '{x}', '{y}'].join('/') +
+    [host, version, name, tileSet.fullName, tileMatrix.identifier, '{z}', '{x}', '{y}'].join('/') +
     `.${tileSet.format}?api=${apiKey}`;
 
   const tileJson: TileJson = { tiles: [tileUrl], tilejson: '3.0.0' };

package/src/routes/tile.wmts.ts

@@ -1,19 +1,17 @@
 import { Config, TileSetType } from '@basemaps/config';
-import { ImageFormat, TileMatrixSet } from '@basemaps/geo';
-import { Env, TileSetName, tileWmtsFromPath } from '@basemaps/shared';
+import { GoogleTms, ImageFormat, Nztm2000QuadTms } from '@basemaps/geo';
+import { Env, 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';
-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';
 
 export function getImageFormats(req: LambdaHttpRequest): ImageFormat[] | undefined {
-  const formats = req.query.getAll('format');
-  if (formats == null || formats.length === 0) return undefined;
+  const formats = [...req.query.getAll('format'), ...req.query.getAll('tileFormat')];
+  if (formats.length === 0) return;
 
   const output: Set<ImageFormat> = new Set();
   for (const fmt of formats) {
@@ -21,7 +19,7 @@ export function getImageFormats(req: LambdaHttpRequest): ImageFormat[] | undefin
     if (parsed == null) continue;
     output.add(parsed);
   }
-  if (output.size === 0) return undefined;
+  if (output.size === 0) return;
   return [...output.values()];
 }
 
@@ -38,18 +36,28 @@ export async function wmts(req: LambdaHttpRequest): Promise<LambdaHttpResponse>
   const host = Env.get(Env.PublicUrlBase) ?? '';
 
   req.timer.start('tileset:load');
-  const tileSets = await wmtsLoadTileSets(wmtsData.name, wmtsData.tileMatrix);
+  const tileSet = await Config.TileSet.get(Config.TileSet.id(wmtsData.name ?? 'aerial'));
   req.timer.end('tileset:load');
-  if (tileSets.length === 0) return NotFound;
+  if (tileSet == null || tileSet.type !== TileSetType.Raster) return NotFound;
 
-  const providerId = Config.Provider.id('linz');
-  const provider = await Config.Provider.get(providerId);
+  const provider = await Config.Provider.get(Config.Provider.id('linz'));
+
+  const tileMatrix = wmtsData.tileMatrix == null ? [GoogleTms, Nztm2000QuadTms] : [wmtsData.tileMatrix];
+  req.timer.start('imagery:load');
+  const imagery = await Config.getAllImagery(
+    tileSet.layers,
+    tileMatrix.map((tms) => tms.projection),
+  );
+  req.timer.end('imagery:load');
 
   const apiKey = Router.apiKey(req);
   const xml = new WmtsCapabilities({
     httpBase: host,
     provider: provider ?? undefined,
-    layers: tileSets,
+    tileSet,
+    tileMatrix,
+    isIndividualLayers: wmtsData.tileMatrix == null,
+    imagery,
     apiKey,
     formats: getImageFormats(req),
   }).toXml();
@@ -67,13 +75,3 @@ export async function wmts(req: LambdaHttpRequest): Promise<LambdaHttpResponse>
   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/tile.set.cache.ts

@@ -1,5 +1,5 @@
 import { TileSetNameParser, TileSetType } from '@basemaps/config';
-import { TileMatrixSet, TileMatrixSets } from '@basemaps/geo';
+import { TileMatrixSet } from '@basemaps/geo';
 import { Config } from '@basemaps/shared';
 import { TileSet } from './tile.set.js';
 import { TileSetRaster } from './tile.set.raster.js';
@@ -79,33 +79,6 @@ export class TileSetCache {
     this.tileSets.set(tileSetId, ts);
     return ts;
   }
-
-  async getAll(name: string, tileMatrix?: TileMatrixSet | null): Promise<TileSet[]> {
-    const nameComp = TileSetNameParser.parse(name);
-    const tileMatrices = tileMatrix == null ? Array.from(TileMatrixSets.Defaults.values()) : [tileMatrix];
-
-    const promises: Promise<TileSet | null>[] = [];
-    for (const tileMatrix of tileMatrices) promises.push(this.get(name, tileMatrix));
-    const tileMatrixSets = await Promise.all(promises);
-
-    const tileSets: TileSetRaster[] = [];
-    for (const parent of tileMatrixSets) {
-      if (parent == null) continue;
-      if (parent.type === TileSetType.Vector) continue;
-
-      tileSets.push(parent);
-      if (nameComp.layer != null) {
-        parent.components.name = nameComp.name;
-      } else if (parent.imagery != null && parent.imagery.size > 1) {
-        for (const imageId of parent.imagery.keys()) {
-          const childImg = parent.child(imageId);
-          if (childImg == null) continue;
-          tileSets.push(childImg);
-        }
-      }
-    }
-    return tileSets.sort((a, b) => a.title.localeCompare(b.title));
-  }
 }
 
 export const TileSets = new TileSetCache();

package/src/tile.set.raster.ts

@@ -84,7 +84,7 @@ export class TileSetRaster {
 
   async init(record: ConfigTileSetRaster): Promise<void> {
     this.tileSet = record;
-    this.imagery = await Config.getAllImagery(this.tileSet.layers, this.tileMatrix.projection);
+    this.imagery = await Config.getAllImagery(this.tileSet.layers, [this.tileMatrix.projection]);
   }
 
   async initTiffs(tile: Tile, log: LogType): Promise<CogTiff[]> {
@@ -213,9 +213,11 @@ export class TileSetRaster {
     child.tileSet = { ...this.tileSet };
     child.tileSet.background = undefined;
     const title = this.tileSet?.title ?? this.tileSet?.name;
-    child.tileSet.title = `${title} ${titleizeImageryName(image.name)}`;
+    child.tileSet.title = image.title ?? `${title} ${titleizeImageryName(image.name)}`;
     child.extentOverride = Bounds.fromJson(image.bounds);
 
+    if (image.category) child.tileSet.category = image.category;
+
     const layer: ConfigLayer = { name: image.name, minZoom: 0, maxZoom: 100 };
     layer[this.tileMatrix.projection.code] = image.id;
 

package/src/tile.set.vector.ts

@@ -1,28 +1,10 @@
 import { ConfigTileSetVector, TileSetNameComponents, TileSetNameParser, TileSetType } from '@basemaps/config';
 import { GoogleTms, TileMatrixSet, VectorFormat } from '@basemaps/geo';
-import { fsa, TileDataXyz } from '@basemaps/shared';
-import { Cotar } from '@cotar/core';
+import { TileDataXyz } from '@basemaps/shared';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import { CotarCache } from './cotar.cache.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>>();
-
-  get(uri: string): Promise<Cotar | null> {
-    let cotar = this.cache.get(uri);
-    if (cotar == null) {
-      const source = fsa.source(uri);
-      St.trace(source);
-      cotar = Cotar.fromTar(source);
-      this.cache.set(uri, cotar);
-    }
-    return cotar;
-  }
-}
-
-export const Layers = new CotarCache();
 
 export class TileSetVector {
   type: TileSetType.Vector = TileSetType.Vector;
@@ -59,7 +41,7 @@ export class TileSetVector {
     if (layer[3857] == null) return new LambdaHttpResponse(500, 'Layer url not found from tileset Config');
 
     req.timer.start('cotar:load');
-    const cotar = await Layers.get(layer[3857]);
+    const cotar = await CotarCache.get(layer[3857]);
     if (cotar == null) return new LambdaHttpResponse(500, 'Failed to load VectorTiles');
     req.timer.end('cotar:load');