@basemaps/lambda-tiler 6.30.0 → 6.32.1

package/dist/node_modules/.package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@basemaps/lambda-tiler",
-  "version": "6.30.0",
+  "version": "6.32.1",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {

package/dist/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@basemaps/lambda-tiler",
-  "version": "6.30.0",
+  "version": "6.32.1",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@basemaps/lambda-tiler",
-      "version": "6.30.0",
+      "version": "6.32.1",
       "license": "MIT",
       "dependencies": {
         "sharp": "0.30.7"

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@basemaps/lambda-tiler",
-  "version": "6.30.0",
+  "version": "6.32.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/linz/basemaps.git",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@basemaps/lambda-tiler",
-  "version": "6.30.0",
+  "version": "6.32.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/linz/basemaps.git",
@@ -22,17 +22,17 @@
   "types": "./build/index.d.ts",
   "license": "MIT",
   "dependencies": {
-    "@basemaps/config": "^6.30.0",
-    "@basemaps/geo": "^6.28.1",
+    "@basemaps/config": "^6.32.1",
+    "@basemaps/geo": "^6.32.1",
     "@basemaps/lambda": "^6.7.0",
-    "@basemaps/shared": "^6.30.0",
-    "@basemaps/tiler": "^6.29.0",
-    "@basemaps/tiler-sharp": "^6.30.0",
+    "@basemaps/shared": "^6.32.1",
+    "@basemaps/tiler": "^6.32.1",
+    "@basemaps/tiler-sharp": "^6.32.1",
     "@chunkd/fs": "^8.4.0",
     "@cogeotiff/core": "^7.0.0",
     "@cotar/core": "^5.4.0",
-    "@linzjs/geojson": "^6.28.1",
-    "@linzjs/lambda": "^3.2.0",
+    "@linzjs/geojson": "^6.32.1",
+    "@linzjs/lambda": "^3.2.1",
     "p-limit": "^4.0.0",
     "path-to-regexp": "^6.1.0",
     "pixelmatch": "^5.1.0",
@@ -52,12 +52,12 @@
     "bundle": "./bundle.sh"
   },
   "devDependencies": {
-    "@basemaps/attribution": "^6.28.1",
+    "@basemaps/attribution": "^6.32.1",
     "@types/aws-lambda": "^8.10.75",
     "@types/node": "^17.0.34",
     "@types/pixelmatch": "^5.0.0",
     "@types/sharp": "^0.30.3",
     "pretty-json-log": "^1.0.0"
   },
-  "gitHead": "c4858d318fd769e086a11e8b2a8f052b54964aab"
+  "gitHead": "4544a7d98667c5274142f1bb6bf61f02e4e5f618"
 }

package/src/__tests__/config.data.ts

@@ -1,5 +1,5 @@
-import { ConfigTileSetRaster, TileSetType, ConfigImagery, ConfigProvider } from '@basemaps/config';
-import { ImageFormat } from '@basemaps/geo';
+import { ConfigImagery, ConfigProvider, ConfigTileSetRaster, ConfigTileSetVector, TileSetType } from '@basemaps/config';
+import { ImageFormat, VectorFormat } from '@basemaps/geo';
 
 export const TileSetAerial: ConfigTileSetRaster = {
   id: 'ts_aerial',
@@ -19,6 +19,24 @@ export const TileSetAerial: ConfigTileSetRaster = {
     },
   ],
 };
+export const TileSetVector: ConfigTileSetVector = {
+  id: 'ts_topographic',
+  type: TileSetType.Vector,
+  name: 'topotgrpahic',
+  description: 'topotgrpahic__description',
+  title: 'topotgrpahic Imagery',
+  category: 'Basemap',
+  format: VectorFormat.MapboxVectorTiles,
+  layers: [
+    {
+      3857: 's3://linz-basemaps/01G7WQMGHB7V946M0YWJJBZ6DW/topopgraphic.tar.co',
+      title: 'Vector tiles',
+      category: 'Vector Tiles',
+      name: 'Vector tiles',
+    },
+  ],
+};
+
 export const Imagery2193: ConfigImagery = {
   id: 'im_01FYWKAJ86W9P7RWM1VB62KD0H',
   name: 'ōtorohanga_urban_2021_0-1m_RGB',
@@ -54,7 +72,7 @@ export const Imagery3857: ConfigImagery = {
 
 export const Provider: ConfigProvider = {
   name: 'main',
-  id: 'pv_main_production',
+  id: 'pv_linz',
   updatedAt: Date.now(),
   version: 1,
   serviceIdentification: {
@@ -80,3 +98,23 @@ export const Provider: ConfigProvider = {
     site: 'https://example.provider.com',
   },
 };
+
+export class FakeData {
+  static tileSetRaster(name: string): ConfigTileSetRaster {
+    const tileSet = JSON.parse(JSON.stringify(TileSetAerial));
+
+    tileSet.name = name;
+    tileSet.id = `ts_${name}`;
+
+    return tileSet;
+  }
+
+  static tileSetVector(name: string): ConfigTileSetVector {
+    const tileSet = JSON.parse(JSON.stringify(TileSetVector));
+
+    tileSet.name = name;
+    tileSet.id = `ts_${name}`;
+
+    return tileSet;
+  }
+}

package/src/__tests__/index.test.ts

@@ -1,24 +1,8 @@
-import { LogConfig } from '@basemaps/shared';
-import { LambdaAlbRequest, LambdaHttpRequest } from '@linzjs/lambda';
-import { Context } from 'aws-lambda';
 import o from 'ospec';
 import { handler } from '../index.js';
+import { mockRequest } from './xyz.util.js';
 
 o.spec('LambdaXyz index', () => {
-  function req(path: string, method = 'get'): LambdaHttpRequest {
-    return new LambdaAlbRequest(
-      {
-        requestContext: null as any,
-        httpMethod: method.toUpperCase(),
-        path,
-        body: null,
-        isBase64Encoded: false,
-      },
-      {} as Context,
-      LogConfig.get(),
-    );
-  }
-
   o('should export handler', async () => {
     const foo = await import('../index.js');
     o(typeof foo.handler).equals('function');
@@ -36,7 +20,7 @@ o.spec('LambdaXyz index', () => {
       process.env.GIT_VERSION = '1.2.3';
       process.env.GIT_HASH = 'abc456';
 
-      const response = await handler.router.handle(req('/v1/version'));
+      const response = await handler.router.handle(mockRequest('/v1/version'));
 
       o(response.status).equals(200);
       o(response.statusDescription).equals('ok');
@@ -49,7 +33,7 @@ o.spec('LambdaXyz index', () => {
   });
 
   o('should respond to /ping', async () => {
-    const res = await handler.router.handle(req('/v1/ping'));
+    const res = await handler.router.handle(mockRequest('/v1/ping'));
     o(res.status).equals(200);
     o(res.statusDescription).equals('ok');
     o(res.header('cache-control')).equals('no-store');

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

@@ -316,22 +316,19 @@ o.spec('WmtsCapabilities', () => {
     const boundingBoxes = tags(layer, 'ows:BoundingBox');
     o(boundingBoxes.length).equals(2);
     o(boundingBoxes[0].attrs.crs).equals('urn:ogc:def:crs:EPSG::3857');
-    o(boundingBoxes[0].children.map((c) => roundNumbersInString(c.textContent, 4))).deepEquals([
+    o(boundingBoxes[0].children.map((c) => c.textContent)).deepEquals([
       '19457809.9203 -4609458.5537',
       '19509787.0995 -4578883.7424',
     ]);
     o(boundingBoxes[1].attrs.crs).equals('urn:ogc:def:crs:EPSG::2193');
-    o(boundingBoxes[1].children.map((c) => roundNumbersInString(c.textContent, 4))).deepEquals([
+    o(boundingBoxes[1].children.map((c) => c.textContent)).deepEquals([
       '5766358.9964 1757351.3045',
       '5793264.8304 1798321.5516',
     ]);
 
     const wgs84 = layer.find('ows:WGS84BoundingBox');
     o(wgs84?.attrs.crs).equals('urn:ogc:def:crs:OGC:2:84');
-    o(wgs84?.children.map((c) => roundNumbersInString(c.textContent, 4))).deepEquals([
-      '174.7925 -38.2123',
-      '175.2594 -37.9962',
-    ]);
+    o(wgs84?.children.map((c) => c.textContent)).deepEquals(['174.79248 -38.212288', '175.259399 -37.996163']);
   });
 
   o('should only output imagery if exists', () => {
@@ -363,4 +360,110 @@ o.spec('WmtsCapabilities', () => {
     const layersB = tags(rawB, 'Layer');
     o(layersB.length).equals(1);
   });
+
+  o('should cover the entire WebMercatorBounds', () => {
+    const halfSize = GoogleTms.extent.width / 2;
+    // Create two fake imagery sets one covers tile z1 x0 y0 another covers tile z1 x1 y1
+    // so the entire bounding box should be tile z0 x0 y0 or the full extent
+    const imagery = new Map();
+    const imageTopLeft = { ...Imagery3857, id: 'im_top_left', name: 'top_left' };
+    imageTopLeft.bounds = { x: -halfSize, y: 0, width: halfSize, height: halfSize };
+    imagery.set(imageTopLeft.id, imageTopLeft);
+
+    const imageBottomRight = { ...Imagery3857, id: 'im_bottom_right', name: 'bottom_right' };
+    imageBottomRight.bounds = { x: 0, y: -halfSize, width: halfSize, height: halfSize };
+    imagery.set(imageBottomRight.id, imageBottomRight);
+
+    const tileSet = { ...TileSetAerial };
+    tileSet.layers = [
+      { 3857: imageTopLeft.id, name: 'a_top_left' },
+      { 3857: imageBottomRight.id, name: 'b_bottom_right' },
+    ];
+
+    const raw = new WmtsCapabilities({
+      httpBase: 'https://basemaps.test',
+      provider: Provider,
+      tileMatrix: [GoogleTms],
+      tileSet,
+      imagery,
+      formats: [ImageFormat.Png],
+      isIndividualLayers: true,
+    }).toVNode();
+
+    const boundingBox = tags(raw, 'ows:WGS84BoundingBox').map((c) =>
+      c
+        .toString()
+        .split('\n')
+        .map((c) => c.trim()),
+    );
+    o(boundingBox[0][1]).deepEquals('<ows:LowerCorner>-180 -85.051129</ows:LowerCorner>');
+    o(boundingBox[0][2]).equals('<ows:UpperCorner>180 85.051129</ows:UpperCorner>');
+
+    o(boundingBox[1][1]).deepEquals('<ows:LowerCorner>-180 0</ows:LowerCorner>');
+    o(boundingBox[1][2]).equals('<ows:UpperCorner>0 85.051129</ows:UpperCorner>');
+
+    o(boundingBox[2][1]).deepEquals('<ows:LowerCorner>0 -85.051129</ows:LowerCorner>');
+    o(boundingBox[2][2]).equals('<ows:UpperCorner>180 0</ows:UpperCorner>');
+  });
+
+  o('should work when crossing anti meridian', () => {
+    const halfSize = GoogleTms.extent.width / 2;
+
+    const imagery = new Map();
+    // This image covers z1 x1.5 y1 to z1 x0.5 y1
+    // which cross the AM and covers half the width of two tiles
+    const imageBottomRight = { ...Imagery3857, id: 'im_bottom_right', name: 'bottom_right' };
+    imageBottomRight.bounds = { x: halfSize / 2, y: -halfSize, width: halfSize, height: halfSize };
+    imagery.set(imageBottomRight.id, imageBottomRight);
+
+    const tileSet = { ...TileSetAerial };
+    tileSet.layers = [{ 3857: imageBottomRight.id, name: 'b_bottom_right' }];
+
+    const raw = new WmtsCapabilities({
+      httpBase: 'https://basemaps.test',
+      provider: Provider,
+      tileMatrix: [GoogleTms],
+      tileSet,
+      imagery,
+      formats: [ImageFormat.Png],
+      isIndividualLayers: true,
+    }).toVNode();
+
+    const boundingBox = tags(raw, 'ows:WGS84BoundingBox').map((c) =>
+      roundNumbersInString(c.toString(), 4)
+        .split('\n')
+        .map((c) => c.trim()),
+    );
+    o(boundingBox[0][1]).deepEquals('<ows:LowerCorner>-180 -85.0511</ows:LowerCorner>');
+    o(boundingBox[0][2]).equals('<ows:UpperCorner>180 0</ows:UpperCorner>');
+
+    o(boundingBox[1][1]).deepEquals('<ows:LowerCorner>-180 -85.0511</ows:LowerCorner>');
+    o(boundingBox[1][2]).equals('<ows:UpperCorner>180 0</ows:UpperCorner>');
+  });
+
+  o('should work with NZTM2000Quad', () => {
+    const wmts = new WmtsCapabilities({ tileMatrix: [] } as any);
+
+    // Full NZTM200Quad coverage
+    const bbox = wmts.buildWgs84BoundingBox(Nztm2000QuadTms, []);
+    o(bbox.children[0].textContent).equals('-180 -49.929855');
+    o(bbox.children[1].textContent).equals('180 2.938603');
+
+    // Full NZTM200Quad coverage at z1
+    const bboxB = wmts.buildWgs84BoundingBox(Nztm2000QuadTms, [
+      Nztm2000QuadTms.tileToSourceBounds({ z: 1, x: 0, y: 0 }),
+      Nztm2000QuadTms.tileToSourceBounds({ z: 1, x: 1, y: 1 }),
+    ]);
+    o(bboxB.children[0].textContent).equals('-180 -49.929855');
+    o(bboxB.children[1].textContent).equals('180 2.938603');
+
+    // Full NZTM200Quad coverage at z5
+    const tileCount = Nztm2000QuadTms.zooms[5].matrixWidth;
+    const bboxC = wmts.buildWgs84BoundingBox(Nztm2000QuadTms, [
+      Nztm2000QuadTms.tileToSourceBounds({ z: 5, x: 0, y: 0 }),
+      Nztm2000QuadTms.tileToSourceBounds({ z: 5, x: tileCount - 1, y: tileCount - 1 }),
+    ]);
+    o(bboxC.children[0].textContent).equals('-180 -49.929855');
+    o(bboxC.children[1].textContent).equals('180 2.938603');
+  });
 });

package/src/__tests__/xyz.util.ts

@@ -1,16 +1,13 @@
-import { TileMatrixSet } from '@basemaps/geo';
 import { LogConfig } from '@basemaps/shared';
-import { LambdaAlbRequest, LambdaHttpRequest } from '@linzjs/lambda';
+import { LambdaAlbRequest, LambdaHttpRequest, LambdaUrlRequest } from '@linzjs/lambda';
 import { Context } from 'aws-lambda';
-import { TileSetRaster } from '../tile.set.raster.js';
-import { TileSetVector } from '../tile.set.vector.js';
 
 export function mockRequest(path: string, method = 'get', headers: Record<string, string> = {}): LambdaHttpRequest {
   return new LambdaAlbRequest(
     {
       requestContext: null as any,
       httpMethod: method.toUpperCase(),
-      path,
+      path: encodeURI(path),
       headers,
       body: null,
       isBase64Encoded: false,
@@ -20,21 +17,21 @@ export function mockRequest(path: string, method = 'get', headers: Record<string
   );
 }
 
-export class FakeTileSet extends TileSetRaster {
-  constructor(name: string, tileMatrix: TileMatrixSet, title = `${name}:title`, description = `${name}:description`) {
-    super(name, tileMatrix);
-    this.tileSet = {
-      name,
-      title,
-      description,
-      layers: [{ name: `imagery_${name}`, [tileMatrix.projection.code]: `im_${title}` }],
-    } as any;
-  }
+export function mockUrlRequest(path: string, query = '', headers: Record<string, unknown> = {}): LambdaHttpRequest {
+  return new LambdaUrlRequest(
+    {
+      requestContext: { http: { method: 'GET' } },
+      headers,
+      rawPath: encodeURI(path),
+      rawQueryString: query,
+      isBase64Encoded: false,
+    } as any,
+    {} as Context,
+    LogConfig.get(),
+  );
 }
 
-export class FakeTileSetVector extends TileSetVector {
-  constructor(name: string, tileMatrix: TileMatrixSet) {
-    super(name, tileMatrix);
-    this.tileSet = {} as any;
-  }
-}
+export const Api = {
+  key: 'd01f7w7rnhdzg0p7fyrc9v9ard1',
+  header: { 'x-linz-api-key': 'd01f7w7rnhdzg0p7fyrc9v9ard1' },
+};

package/src/index.ts

@@ -1,56 +1,93 @@
 import { LogConfig } from '@basemaps/shared';
-import { LambdaHttpRequest, LambdaHttpResponse, lf } from '@linzjs/lambda';
-import { createHash } from 'crypto';
-import { Router } from './router.js';
-import { Ping, Version } from './routes/api.js';
+import { LambdaHttpResponse, LambdaUrlRequest, lf } from '@linzjs/lambda';
+import { tileAttributionGet } from './routes/attribution.js';
 import { fontGet, fontList } from './routes/fonts.js';
-import { Health } from './routes/health.js';
+import { healthGet } from './routes/health.js';
 import { imageryGet } from './routes/imagery.js';
+import { pingGet } from './routes/ping.js';
 import { spriteGet } from './routes/sprites.js';
-import { Tiles } from './routes/tile.js';
-import { St } from './source.tracer.js';
-
-const app = new Router();
-
-app.get('tiles', Tiles);
-
-export async function handleRequest(req: LambdaHttpRequest): Promise<LambdaHttpResponse> {
-  const apiKey = Router.apiKey(req);
-  if (apiKey != null) {
-    const apiKeyHash = createHash('sha256').update(apiKey).digest('base64');
-    req.set('api', apiKeyHash);
-  }
-  return await app.handle(req);
-}
+import { tileJsonGet } from './routes/tile.json.js';
+import { styleJsonGet } from './routes/tile.style.json.js';
+import { wmtsCapabilitiesGet } from './routes/tile.wmts.js';
+import { tileXyzGet } from './routes/tile.xyz.js';
+import { versionGet } from './routes/version.js';
+import { NotFound } from './util/response.js';
+import { CoSources } from './util/source.cache.js';
+import { St } from './util/source.tracer.js';
 
 export const handler = lf.http(LogConfig.get());
 
 handler.router.hook('request', (req) => {
   req.set('name', 'LambdaTiler');
+
   // Reset the request tracing before every request
   St.reset();
 });
 
-handler.router.hook('response', (req) => {
+handler.router.hook('response', (req, res) => {
   if (St.requests.length > 0) {
     // TODO this could be relaxed to every say 5% of requests if logging gets too verbose.
     req.set('requests', St.requests.slice(0, 100)); // limit to 100 requests (some tiles need 100s of requests)
     req.set('requestCount', St.requests.length);
   }
+  // Log the source cache hit/miss ratio
+  req.set('sources', {
+    hits: CoSources.cache.hits,
+    misses: CoSources.cache.misses,
+    size: CoSources.cache.currentSize,
+    resets: CoSources.cache.resets,
+    cacheA: CoSources.cache.cacheA.size,
+    cacheB: CoSources.cache.cacheB.size,
+  });
+
+  // FunctionURLs automatically inject CORS responses for us
+  if (!(req instanceof LambdaUrlRequest) && req.headers.has('origin')) {
+    res.header('access-control-allow-origin', '*');
+  }
+});
+
+// CORS is handled by function url hook so just return ok if the route exists
+handler.router.options('*', (req) => {
+  const route = handler.router.router.find('GET', req.path);
+  if (route == null) return NotFound();
+  return LambdaHttpResponse.ok();
 });
+
 // TODO some internal health checks hit these routes, we should change them all to point at /v1/
-handler.router.get('/ping', Ping);
-handler.router.get('/health', Health);
-handler.router.get('/version', Version);
+handler.router.get('/ping', pingGet);
+handler.router.get('/health', healthGet);
+handler.router.get('/version', versionGet);
 
-handler.router.get('/v1/ping', Ping);
-handler.router.get('/v1/health', Health);
-handler.router.get('/v1/version', Version);
+handler.router.get('/v1/ping', pingGet);
+handler.router.get('/v1/health', healthGet);
+handler.router.get('/v1/version', versionGet);
 
+// Image Metadata
 handler.router.get('/v1/imagery/:imageryId/:fileName', imageryGet);
+
+// Sprites
 handler.router.get('/v1/sprites/:spriteName', spriteGet);
+
+// Fonts
 handler.router.get('/v1/fonts.json', fontList);
 handler.router.get('/v1/fonts/:fontStack/:range.pbf', fontGet);
 
-// Catch all for old requests
-handler.router.get('*', handleRequest);
+// StyleJSON
+handler.router.get('/v1/styles/:styleName.json', styleJsonGet);
+/** @deprecated 2022-07-22 all styles should be being served from /v1/styles/:styleName.json */
+handler.router.get('/v1/tiles/:tileSet/:tileMatrix/style/:styleName.json', styleJsonGet);
+
+// TileJSON
+handler.router.get('/v1/tiles/:tileSet/:tileMatrix/tile.json', tileJsonGet);
+
+// Tiles
+handler.router.get('/v1/tiles/:tileSet/:tileMatrix/:z/:x/:y.:tileType', tileXyzGet);
+
+// Attribution
+handler.router.get('/v1/tiles/:tileSet/:tileMatrix/attribution.json', tileAttributionGet);
+handler.router.get('/v1/attribution/:tileSet/:tileMatrix/summary.json', tileAttributionGet);
+
+// WMTS Capabilities
+handler.router.get('/v1/tiles/:tileSet/:tileMatrix/WMTSCapabilities.xml', wmtsCapabilitiesGet);
+handler.router.get('/v1/tiles/:tileSet/WMTSCapabilities.xml', wmtsCapabilitiesGet);
+handler.router.get('/v1/tiles/WMTSCapabilities.xml', wmtsCapabilitiesGet);