@basemaps/lambda-tiler 7.7.0 → 7.10.0

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

@@ -4,13 +4,15 @@ import { afterEach, before, beforeEach, describe, it } from 'node:test';
 import { ConfigProviderMemory } from '@basemaps/config';
 import { LogConfig } from '@basemaps/shared';
 import { LambdaAlbRequest, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import { VectorTile, VectorTileFeature, VectorTileLayer } from '@mapbox/vector-tile';
 import { ALBEventRequestContext, Context } from 'aws-lambda';
 import sinon from 'sinon';
 
 import { FakeData } from '../../__tests__/config.data.js';
 import { ConfigLoader } from '../../util/config.loader.js';
-import { getTestBuffer, healthGet, TestTiles } from '../health.js';
+import { getTestBuffer, healthGet, TestFeature, TestTiles, VectorTileProvider } from '../health.js';
 import { TileXyzRaster } from '../tile.xyz.raster.js';
+import { tileXyzVector } from '../tile.xyz.vector.js';
 
 const ctx: LambdaHttpRequest = new LambdaAlbRequest(
   {
@@ -24,15 +26,38 @@ const ctx: LambdaHttpRequest = new LambdaAlbRequest(
   LogConfig.get(),
 );
 
+//  Function to create a vector tile with specific properties for testing
+function createTestTile(testFeatures: TestFeature[]): VectorTile {
+  const layers: Record<string, VectorTileLayer> = {};
+  for (const testFeature of testFeatures) {
+    const layer = {
+      features: [{ properties: { [testFeature.key]: testFeature.value } }],
+
+      feature(i: number): VectorTileFeature {
+        return this.features[i] as VectorTileFeature;
+      },
+
+      get length(): number {
+        return this.features.length;
+      },
+    };
+
+    layers[testFeature.layer] = layer as unknown as VectorTileLayer;
+  }
+  return { layers } as unknown as VectorTile;
+}
+
 describe('/v1/health', () => {
   const sandbox = sinon.createSandbox();
   const config = new ConfigProviderMemory();
 
-  const fakeTileSet = FakeData.tileSetRaster('health');
+  const fakeTileSetRaster = FakeData.tileSetRaster('health');
+  const fakeTileSetVector = FakeData.tileSetVector('topographic');
   beforeEach(() => {
     config.objects.clear();
     sandbox.stub(ConfigLoader, 'getDefaultConfig').resolves(config);
-    config.put(fakeTileSet);
+    config.put(fakeTileSetRaster);
+    config.put(fakeTileSetVector);
   });
 
   afterEach(() => {
@@ -40,17 +65,14 @@ describe('/v1/health', () => {
     sandbox.restore();
   });
 
-  it('Should return bad response', async () => {
+  it('Should return bad response', () => {
     // Given ... a bad get tile response
     const BadResponse = new LambdaHttpResponse(500, 'Can not get Tile Set.');
     sandbox.stub(TileXyzRaster, 'tile').resolves(BadResponse);
+    sandbox.stub(tileXyzVector, 'tile').resolves(BadResponse);
 
-    // When ...
-    const res = await healthGet(ctx);
-
-    // Then ...
-    assert.equal(res.status, 500);
-    assert.equal(res.statusDescription, 'Can not get Tile Set.');
+    // When ...Then ...
+    assert.rejects(() => healthGet(ctx), BadResponse);
   });
 
   const Response1 = new LambdaHttpResponse(200, 'ok');
@@ -66,9 +88,15 @@ describe('/v1/health', () => {
 
   it('Should give a 200 response', async () => {
     // Given ... a series good get tile response
-    const callback = sandbox.stub(TileXyzRaster, 'tile');
-    callback.onCall(0).resolves(Response1);
-    callback.onCall(1).resolves(Response2);
+    const callbackRaster = sandbox.stub(TileXyzRaster, 'tile');
+
+    callbackRaster.onCall(0).resolves(Response1);
+    callbackRaster.onCall(1).resolves(Response2);
+    const callbackVectorTile = sandbox.stub(VectorTileProvider, 'getVectorTile');
+    const testVectorTile1 = createTestTile(TestTiles[2].testFeatures!);
+    const testVectorTile2 = createTestTile(TestTiles[3].testFeatures!);
+    callbackVectorTile.onCall(0).resolves(testVectorTile1);
+    callbackVectorTile.onCall(1).resolves(testVectorTile2);
 
     // When ...
     const res = await healthGet(ctx);
@@ -78,17 +106,13 @@ describe('/v1/health', () => {
     assert.equal(res.statusDescription, 'ok');
   });
 
-  it('Should return mis-match tile response', async () => {
+  it('Should return mis-match tile response', () => {
     // Given ... a bad get tile response for second get tile
     const callback = sandbox.stub(TileXyzRaster, 'tile');
-    callback.onCall(0).resolves(Response1);
-    callback.onCall(1).resolves(Response1);
+    callback.onCall(0).resolves(Response2);
 
-    // When ...
-    const res = await healthGet(ctx);
-
-    // Then ...
-    assert.equal(res.status, 500);
-    assert.equal(res.statusDescription, 'TileSet does not match.');
+    // When ... Then ...
+    const BadResponse = new LambdaHttpResponse(500, 'TileSet does not match.');
+    assert.rejects(() => healthGet(ctx), BadResponse);
   });
 });

package/src/routes/__tests__/tile.style.json.test.ts

@@ -380,4 +380,95 @@ describe('/v1/styles', () => {
     assert.deepEqual(terrain.source, 'LINZ-Terrain');
     assert.deepEqual(terrain.exaggeration, 1.2);
   });
+
+  it('should set labels via parameter', async () => {
+    config.put(TileSetAerial);
+    config.put(TileSetElevation);
+
+    const fakeStyle = { id: 'st_labels', name: 'labels', style: fakeVectorStyleConfig };
+    config.put(fakeStyle);
+
+    const request = mockUrlRequest('/v1/styles/aerial.json', `?terrain=LINZ-Terrain&labels=true`, Api.header);
+    const res = await handler.router.handle(request);
+    assert.equal(res.status, 200, res.statusDescription);
+
+    const body = JSON.parse(Buffer.from(res.body, 'base64').toString()) as StyleJson;
+    const terrain = body.terrain as unknown as Terrain;
+    assert.deepEqual(terrain.source, 'LINZ-Terrain');
+    assert.deepEqual(terrain.exaggeration, 1.2);
+
+    assert.equal(body.sources['basemaps_vector']?.type, 'vector');
+    assert.equal(body.layers.length, 2);
+  });
+
+  it('should error when joining layers with duplicate ids', async () => {
+    const fakeStyle = { id: 'st_labels', name: 'labels', style: fakeVectorStyleConfig };
+    config.put(fakeStyle);
+    config.put(TileSetAerial);
+
+    const request = mockUrlRequest('/v1/styles/labels.json', `?labels=true`, Api.header);
+    const res = await handler.router.handle(request);
+    assert.equal(res.status, 400, res.statusDescription);
+    assert.equal(res.statusDescription.includes('Background1'), true);
+  });
+
+  it('should convert NZTM2000Quad styles', async () => {
+    const fakeStyle = {
+      id: 'st_labels',
+      name: 'source',
+      style: {
+        layers: [
+          {
+            minzoom: 5,
+            maxzoom: 5,
+            layout: {
+              'line-width': {
+                stops: [
+                  [16, 0.75],
+                  [24, 1.5],
+                ],
+              },
+            },
+
+            paint: {
+              'line-width': {
+                stops: [
+                  [16, 0.75],
+                  [24, 1.5],
+                ],
+              },
+            },
+          },
+        ],
+        terrain: {
+          exaggeration: 1.1,
+        },
+      },
+    };
+    config.put(fakeStyle);
+
+    const request = mockUrlRequest('/v1/styles/labels.json', `?tileMatrix=NZTM2000Quad`, Api.header);
+    const res = await handler.router.handle(request);
+    assert.equal(res.status, 200, res.statusDescription);
+    const style = JSON.parse(Buffer.from(res.body, 'base64').toString()) as StyleJson;
+    assert.equal(style.layers[0].minzoom, 3);
+    assert.equal(style.layers[0].maxzoom, 3);
+    assert.equal(style.terrain?.exaggeration, 4.4);
+    assert.deepEqual(style.layers[0].layout, {
+      'line-width': {
+        stops: [
+          [14, 0.75],
+          [22, 1.5],
+        ],
+      },
+    });
+    assert.deepEqual(style.layers[0].paint, {
+      'line-width': {
+        stops: [
+          [14, 0.75],
+          [22, 1.5],
+        ],
+      },
+    });
+  });
 });

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

@@ -10,6 +10,7 @@ import { Api, mockRequest, mockUrlRequest } from '../../__tests__/xyz.util.js';
 import { handler } from '../../index.js';
 import { ConfigLoader } from '../../util/config.loader.js';
 import { Etag } from '../../util/etag.js';
+import { CoSources } from '../../util/source.cache.js';
 
 const TileSetNames = ['aerial', 'aerial:ōtorohanga_urban_2021_0-1m_RGB', '01FYWKAJ86W9P7RWM1VB62KD0H'];
 describe('/v1/tiles', () => {
@@ -197,4 +198,21 @@ describe('/v1/tiles', () => {
     );
     assert.equal(resZz.status, 400, resZz.statusDescription);
   });
+
+  it('should support NZTM2000Quad vector tiles', async (t) => {
+    t.mock.method(ConfigLoader, 'getDefaultConfig', () => Promise.resolve(config));
+
+    // Force resolve a basic tile
+    const mockGetTile = t.mock.fn(() => Promise.resolve(Buffer.from('ABC123')));
+    t.mock.method(CoSources, 'getCotar', () => Promise.resolve({ get: mockGetTile }));
+
+    const topographic = FakeData.tileSetVector('topographic');
+    topographic.layers[0][2193] = 'memory://fake-tiles.tar.co';
+    config.put(topographic);
+    const resPbf = await handler.router.handle(
+      mockUrlRequest('/v1/tiles/topographic/NZTM2000Quad/11/2022/1283.pbf', 'get', Api.header),
+    );
+    assert.equal(resPbf.status, 200);
+    assert.equal(resPbf.body, Buffer.from('ABC123').toString('base64'));
+  });
 });

package/src/routes/health.ts

@@ -1,23 +1,67 @@
 import * as fs from 'node:fs';
 
-import { ConfigTileSetRaster } from '@basemaps/config';
+import { ConfigTileSetRaster, ConfigTileSetVector, TileSetType } from '@basemaps/config';
 import { GoogleTms, Nztm2000QuadTms } from '@basemaps/geo';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import { VectorTile } from '@mapbox/vector-tile';
+import Protobuf from 'pbf';
 import PixelMatch from 'pixelmatch';
 import Sharp from 'sharp';
+import { gunzipSync } from 'zlib';
 
 import { ConfigLoader } from '../util/config.loader.js';
+import { isGzip } from '../util/cotar.serve.js';
 import { TileXyz } from '../util/validate.js';
 import { TileXyzRaster } from './tile.xyz.raster.js';
+import { tileXyzVector } from './tile.xyz.vector.js';
+
+/**
+ * Vector feature that need to check existence
+ */
+export interface TestFeature {
+  layer: string;
+  key: string;
+  value: string;
+}
 
 interface TestTile extends TileXyz {
   buf?: Buffer;
+  testFeatures?: TestFeature[];
 }
 
 export const TestTiles: TestTile[] = [
   { tileSet: 'health', tileMatrix: GoogleTms, tileType: 'png', tile: { x: 252, y: 156, z: 8 } },
   { tileSet: 'health', tileMatrix: Nztm2000QuadTms, tileType: 'png', tile: { x: 30, y: 33, z: 6 } },
+  {
+    tileSet: 'topographic',
+    tileMatrix: GoogleTms,
+    tileType: 'pbf',
+    tile: { x: 1009, y: 641, z: 10 },
+    testFeatures: [
+      { layer: 'aeroway', key: 'name', value: 'Wellington Airport' },
+      { layer: 'place', key: 'name', value: 'Wellington' },
+      { layer: 'coastline', key: 'class', value: 'coastline' },
+      { layer: 'landcover', key: 'class', value: 'grass' },
+      { layer: 'poi', key: 'name', value: 'Seatoun Wharf' },
+      { layer: 'transportation', key: 'name', value: 'Mt Victoria Tunnel' },
+    ],
+  },
+  {
+    tileSet: 'topographic',
+    tileMatrix: GoogleTms,
+    tileType: 'pbf',
+    tile: { x: 62, y: 40, z: 6 },
+    testFeatures: [
+      { layer: 'landuse', key: 'name', value: 'Queenstown' },
+      { layer: 'place', key: 'name', value: 'Christchurch' },
+      { layer: 'water', key: 'name', value: 'Tasman Lake' },
+      { layer: 'coastline', key: 'class', value: 'coastline' },
+      { layer: 'landcover', key: 'class', value: 'wood' },
+      { layer: 'transportation', key: 'name', value: 'STATE HIGHWAY 6' },
+    ],
+  },
 ];
+
 const TileSize = 256;
 
 export async function getTestBuffer(test: TestTile): Promise<Buffer> {
@@ -40,6 +84,82 @@ export async function updateExpectedTile(test: TestTile, newTileData: Buffer, di
   await fs.promises.writeFile(`${expectedFileName}.diff.png`, imgPng);
 }
 
+/**
+ * Compare and validate the raster test tile from server with pixel match
+ */
+async function validateRasterTile(tileSet: ConfigTileSetRaster, test: TestTile, req: LambdaHttpRequest): Promise<void> {
+  // Get the parse response tile to raw buffer
+  const response = await TileXyzRaster.tile(req, tileSet, test);
+  if (response.status !== 200) throw new LambdaHttpResponse(500, response.statusDescription);
+  if (!Buffer.isBuffer(response._body)) throw new LambdaHttpResponse(500, 'Not a Buffer response content.');
+  const resImgBuffer = await Sharp(response._body).raw().toBuffer();
+
+  // Get test tile to compare
+  const testBuffer = await getTestBuffer(test);
+  test.buf = testBuffer;
+  const testImgBuffer = await Sharp(testBuffer).raw().toBuffer();
+
+  const outputBuffer = Buffer.alloc(testImgBuffer.length);
+  const missMatchedPixels = PixelMatch(testImgBuffer, resImgBuffer, outputBuffer, TileSize, TileSize);
+  if (missMatchedPixels) {
+    /** Uncomment this to overwite the expected files */
+    // await updateExpectedTile(test, response._body as Buffer, outputBuffer);
+    req.log.error({ missMatchedPixels, projection: test.tileMatrix.identifier, xyz: test.tile }, 'Health:MissMatch');
+    throw new LambdaHttpResponse(500, 'TileSet does not match.');
+  }
+}
+
+function checkFeatureExists(tile: VectorTile, testFeature: TestFeature): boolean {
+  const layer = tile.layers[testFeature.layer];
+  for (let i = 0; i < layer.length; i++) {
+    const feature = layer.feature(i);
+    if (feature.properties[testFeature.key] === testFeature.value) return true;
+  }
+  return false;
+}
+
+/**
+ * Fetch vector tile and decode into mapbox VectorTile
+ */
+export const VectorTileProvider = {
+  async getVectorTile(tileSet: ConfigTileSetVector, test: TestTile, req: LambdaHttpRequest): Promise<VectorTile> {
+    // Get the parse response tile to raw buffer
+    const response = await tileXyzVector.tile(req, tileSet, test);
+    if (response.status !== 200) throw new LambdaHttpResponse(500, response.statusDescription);
+    if (!Buffer.isBuffer(response._body)) throw new LambdaHttpResponse(500, 'Not a Buffer response content.');
+    const buffer = isGzip(response._body) ? gunzipSync(response._body) : response._body;
+    return new VectorTile(new Protobuf(buffer));
+  },
+};
+
+/**
+ * Check the existence of a feature property in side the vector tile
+ *
+ * @throws LambdaHttpResponse if any test feature not found from vector tile
+ */
+function featureCheck(tile: VectorTile, testTile: TestTile): void {
+  const testTileName = `${testTile.tileSet}-${testTile.tile.x}/${testTile.tile.y}/z${testTile.tile.z}`;
+  if (testTile.testFeatures == null) {
+    throw new LambdaHttpResponse(500, `No test feature found from testTile: ${testTileName}`);
+  }
+  for (const testFeature of testTile.testFeatures) {
+    if (!checkFeatureExists(tile, testFeature)) {
+      throw new LambdaHttpResponse(500, `Failed to validate tile: ${testTileName} for layer: ${testFeature.layer}.`);
+    }
+  }
+}
+
+/**
+ * Health check the test vector tiles that contains all the expected features.
+ *
+ * @throws LambdaHttpResponse if test tiles not returned or features not exists
+ */
+async function validateVectorTile(tileSet: ConfigTileSetVector, test: TestTile, req: LambdaHttpRequest): Promise<void> {
+  // Get the parse response tile to raw buffer
+  const tile = await VectorTileProvider.getVectorTile(tileSet, test, req);
+  featureCheck(tile, test);
+}
+
 /**
  * Health request get health TileSets and validate with test TileSets
  * - Valid response from get heath tile request
@@ -49,27 +169,15 @@ export async function updateExpectedTile(test: TestTile, newTileData: Buffer, di
  */
 export async function healthGet(req: LambdaHttpRequest): Promise<LambdaHttpResponse> {
   const config = await ConfigLoader.load(req);
-  const tileSet = await config.TileSet.get(config.TileSet.id('health'));
-  if (tileSet == null) throw new LambdaHttpResponse(500, 'TileSet: "health" not found');
   for (const test of TestTiles) {
-    // Get the parse response tile to raw buffer
-    const response = await TileXyzRaster.tile(req, tileSet as ConfigTileSetRaster, test);
-    if (response.status !== 200) return new LambdaHttpResponse(500, response.statusDescription);
-    if (!Buffer.isBuffer(response._body)) throw new LambdaHttpResponse(500, 'Not a Buffer response content.');
-    const resImgBuffer = await Sharp(response._body).raw().toBuffer();
-
-    // Get test tile to compare
-    const testBuffer = await getTestBuffer(test);
-    test.buf = testBuffer;
-    const testImgBuffer = await Sharp(testBuffer).raw().toBuffer();
-
-    const outputBuffer = Buffer.alloc(testImgBuffer.length);
-    const missMatchedPixels = PixelMatch(testImgBuffer, resImgBuffer, outputBuffer, TileSize, TileSize);
-    if (missMatchedPixels) {
-      /** Uncomment this to overwite the expected files */
-      // await updateExpectedTile(test, response._body as Buffer, outputBuffer);
-      req.log.error({ missMatchedPixels, projection: test.tileMatrix.identifier, xyz: test.tile }, 'Health:MissMatch');
-      return new LambdaHttpResponse(500, 'TileSet does not match.');
+    const tileSet = await config.TileSet.get(config.TileSet.id(test.tileSet));
+    if (tileSet == null) throw new LambdaHttpResponse(500, `TileSet: ${test.tileSet} not found`);
+    if (tileSet.type === TileSetType.Raster) {
+      await validateRasterTile(tileSet, test, req);
+    } else if (tileSet.type === TileSetType.Vector) {
+      await validateVectorTile(tileSet, test, req);
+    } else {
+      throw new LambdaHttpResponse(500, `Invalid TileSet type for tileSet ${test.tileSet}`);
     }
   }