@basemaps/lambda-tiler 7.3.0 → 7.5.0

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

@@ -3,7 +3,7 @@ import { afterEach, beforeEach, describe, it } from 'node:test';
 
 import { Attribution } from '@basemaps/attribution';
 import { ConfigProviderMemory } from '@basemaps/config';
-import { GoogleTms, Nztm2000QuadTms, Projection } from '@basemaps/geo';
+import { AttributionStac, GoogleTms, Nztm2000QuadTms, Projection } from '@basemaps/geo';
 import { LogConfig } from '@basemaps/shared';
 import { BBox } from '@linzjs/geojson';
 import { HttpHeader } from '@linzjs/lambda';
@@ -328,7 +328,7 @@ describe('/v1/attribution', () => {
     const res = await handler.router.handle(request);
     assert.equal(res.status, 200);
 
-    const json = JSON.parse(res.body);
+    const json = JSON.parse(res.body) as AttributionStac;
 
     const attr = Attribution.fromStac(json);
     assert.equal(attr.attributions.length, 1);
@@ -351,7 +351,7 @@ describe('/v1/attribution', () => {
       const res = await handler.router.handle(req);
       assert.equal(res.status, 200);
 
-      const output = JSON.parse(res.body);
+      const output = JSON.parse(res.body) as AttributionStac;
       assert.equal(output.title, ts.title);
       assert.deepEqual(output.collections[0].summaries['linz:zoom'], { min: 5, max: 11 });
     });
@@ -361,7 +361,7 @@ describe('/v1/attribution', () => {
       const res = await handler.router.handle(req);
       assert.equal(res.status, 200);
 
-      const output = JSON.parse(res.body);
+      const output = JSON.parse(res.body) as AttributionStac;
       assert.equal(output.title, ts.title);
       assert.deepEqual(output.collections[0].summaries['linz:zoom'], { min: 7, max: 14 });
     });
@@ -374,7 +374,7 @@ describe('/v1/attribution', () => {
       const res = await handler.router.handle(req);
       assert.equal(res.status, 200);
 
-      const output = JSON.parse(res.body);
+      const output = JSON.parse(res.body) as AttributionStac;
       assert.equal(output.title, ts.title);
       assert.deepEqual(output.collections[0].summaries['linz:zoom'], { min: 0, max: 13 });
     });
@@ -387,13 +387,13 @@ describe('/v1/attribution', () => {
       const res = await handler.router.handle(req);
       assert.equal(res.status, 200);
 
-      const output = JSON.parse(res.body);
+      const output = JSON.parse(res.body) as AttributionStac;
       assert.equal(output.title, ts.title);
       assert.deepEqual(output.collections[0].summaries['linz:zoom'], { min: 0, max: Nztm2000QuadTms.maxZoom });
     });
   });
 
-  it('should create valid coordinates', async () => {
+  it('should create valid coordinates', () => {
     //bbox: BBox, files: NamedBounds[], proj: Projection
     const bbox = [174.79248047, -38.21228805, 175.25939941, -37.99616268] as BBox;
     const proj = Projection.get(GoogleTms);

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

@@ -4,7 +4,7 @@ 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 { Context } from 'aws-lambda';
+import { ALBEventRequestContext, Context } from 'aws-lambda';
 import sinon from 'sinon';
 
 import { FakeData } from '../../__tests__/config.data.js';
@@ -14,7 +14,7 @@ import { TileXyzRaster } from '../tile.xyz.raster.js';
 
 const ctx: LambdaHttpRequest = new LambdaAlbRequest(
   {
-    requestContext: null as any,
+    requestContext: null as unknown as ALBEventRequestContext,
     httpMethod: 'get',
     path: '/v1/tiles/health',
     body: null,
@@ -24,7 +24,7 @@ const ctx: LambdaHttpRequest = new LambdaAlbRequest(
   LogConfig.get(),
 );
 
-describe('/v1/health', async () => {
+describe('/v1/health', () => {
   const sandbox = sinon.createSandbox();
   const config = new ConfigProviderMemory();
 

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

@@ -10,6 +10,6 @@ describe('ImageryRoute', () => {
     assert.equal(isAllowedFile('foo.tiff'), false);
     assert.equal(isAllowedFile('foo'), false);
     assert.equal(isAllowedFile(''), false);
-    assert.equal(isAllowedFile(null as any), false);
+    assert.equal(isAllowedFile(null as unknown as string), false);
   });
 });

package/src/routes/__tests__/memory.fs.ts

@@ -4,9 +4,9 @@ export async function toBuffer(stream: Readable): Promise<Buffer> {
   return new Promise<Buffer>((resolve, reject) => {
     const buf: Buffer[] = [];
 
-    stream.on('data', (chunk) => buf.push(chunk));
+    stream.on('data', (chunk: Buffer) => buf.push(chunk));
     stream.on('end', () => resolve(Buffer.concat(buf)));
-    stream.on('error', (err) => reject(`error converting stream - ${err}`));
+    stream.on('error', (err) => reject(`error converting stream - ${String(err)}`));
   });
 }
 export function toReadable(r: string | Buffer | Readable): Readable {

package/src/routes/__tests__/preview.index.test.ts

@@ -5,16 +5,16 @@ import { ConfigProviderMemory, DefaultColorRampOutput, DefaultTerrainRgbOutput }
 import { LocationUrl } from '@basemaps/geo';
 import { Env, fsa, FsMemory, LogConfig, V } from '@basemaps/shared';
 import { LambdaAlbRequest, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
-import { ALBEvent, Context } from 'aws-lambda';
+import { ALBEvent, ALBEventRequestContext, Context } from 'aws-lambda';
 
 import { FakeData } from '../../__tests__/config.data.js';
 import { CachedConfig } from '../../util/config.cache.js';
 import { loadAndServeIndexHtml, PreviewIndexGet, previewIndexGet } from '../preview.index.js';
 
-describe('/@*', async () => {
+describe('/@*', () => {
   // o.specTimeout(1000);
   const baseRequest: ALBEvent = {
-    requestContext: null as any,
+    requestContext: null as unknown as ALBEventRequestContext,
     httpMethod: 'get',
     path: '/@-41.8900012,174.0492432,z5',
     body: null,

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

@@ -149,7 +149,7 @@ describe('/v1/tiles/:tileSet/:tileMatrix/tile.json', () => {
     const res = await handler.router.handle(request);
     assert.equal(res.status, 200);
 
-    const body = JSON.parse(Buffer.from(res.body, 'base64').toString());
+    const body = JSON.parse(Buffer.from(res.body, 'base64').toString()) as { tiles: string[] };
     assert.equal(body.tiles[0].includes(`config=${configLocation}`), true);
   });
 

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

@@ -1,11 +1,12 @@
 import assert from 'node:assert';
 import { afterEach, before, beforeEach, describe, it } from 'node:test';
 
-import { ConfigProviderMemory, StyleJson } from '@basemaps/config';
+import { ConfigProviderMemory, SourceRaster, StyleJson } from '@basemaps/config';
+import { Terrain } from '@basemaps/config/src/config/vector.style.js';
 import { Env } from '@basemaps/shared';
 import { createSandbox } from 'sinon';
 
-import { FakeData } from '../../__tests__/config.data.js';
+import { FakeData, TileSetAerial, TileSetElevation } from '../../__tests__/config.data.js';
 import { Api, mockRequest, mockUrlRequest } from '../../__tests__/xyz.util.js';
 import { handler } from '../../index.js';
 import { ConfigLoader } from '../../util/config.loader.js';
@@ -48,6 +49,10 @@ describe('/v1/styles', () => {
         type: 'raster',
         tiles: [`/raster/{z}/{x}/{y}.webp`], // Shouldn't encode the {}
       },
+      basemaps_terrain: {
+        type: 'raster-dem',
+        tiles: [`/elevation/{z}/{x}/{y}.png?pipeline=terrain-rgb`],
+      },
       test_vector: {
         type: 'vector',
         url: 'vector.url.co.nz',
@@ -127,6 +132,11 @@ describe('/v1/styles', () => {
       tiles: [`${host}/raster/{z}/{x}/{y}.webp?api=${Api.key}`],
     };
 
+    fakeStyle.sources['basemaps_terrain'] = {
+      type: 'raster-dem',
+      tiles: [`${host}/elevation/{z}/{x}/{y}.png?pipeline=terrain-rgb&api=${Api.key}`],
+    };
+
     fakeStyle.sprite = `${host}/sprite`;
     fakeStyle.glyphs = `${host}/glyphs`;
 
@@ -174,14 +184,16 @@ describe('/v1/styles', () => {
     const res = await handler.router.handle(request);
     assert.equal(res.status, 200, res.statusDescription);
 
-    const body = JSON.parse(Buffer.from(res.body, 'base64').toString());
+    const body = JSON.parse(Buffer.from(res.body, 'base64').toString()) as StyleJson;
 
     assert.equal(body.version, 8);
-    assert.deepEqual(body.sources['basemaps-aerial'].type, 'raster');
-    assert.deepEqual(body.sources['basemaps-aerial'].tiles, [
+
+    const aerialSource = body.sources['basemaps-aerial'] as SourceRaster;
+    assert.deepEqual(aerialSource.type, 'raster');
+    assert.deepEqual(aerialSource.tiles, [
       `https://tiles.test/v1/tiles/aerial/WebMercatorQuad/{z}/{x}/{y}.webp?api=${Api.key}`,
     ]);
-    assert.deepEqual(body.sources['basemaps-aerial'].tileSize, 256);
+    assert.deepEqual(aerialSource.tileSize, 256);
     assert.deepEqual(body.layers, [{ id: 'basemaps-aerial', type: 'raster', source: 'basemaps-aerial' }]);
   });
 
@@ -192,14 +204,16 @@ describe('/v1/styles', () => {
     const res = await handler.router.handle(request);
     assert.equal(res.status, 200, res.statusDescription);
 
-    const body = JSON.parse(Buffer.from(res.body, 'base64').toString());
+    const body = JSON.parse(Buffer.from(res.body, 'base64').toString()) as StyleJson;
 
     assert.equal(body.version, 8);
-    assert.deepEqual(body.sources['basemaps-aerial'].type, 'raster');
-    assert.deepEqual(body.sources['basemaps-aerial'].tiles, [
+    const aerialSource = body.sources['basemaps-aerial'] as unknown as SourceRaster;
+
+    assert.deepEqual(aerialSource.type, 'raster');
+    assert.deepEqual(aerialSource.tiles, [
       `https://tiles.test/v1/tiles/aerial/NZTM2000Quad/{z}/{x}/{y}.jpeg?api=${Api.key}`,
     ]);
-    assert.deepEqual(body.sources['basemaps-aerial'].tileSize, 256);
+    assert.deepEqual(aerialSource.tileSize, 256);
     assert.deepEqual(body.layers, [{ id: 'basemaps-aerial', type: 'raster', source: 'basemaps-aerial' }]);
   });
 
@@ -210,14 +224,160 @@ describe('/v1/styles', () => {
     const res = await handler.router.handle(request);
     assert.equal(res.status, 200, res.statusDescription);
 
-    const body = JSON.parse(Buffer.from(res.body, 'base64').toString());
+    const body = JSON.parse(Buffer.from(res.body, 'base64').toString()) as StyleJson;
+    body.sources['basemaps-aerial'];
+    body.sources['basemaps-aerial'];
+    body.sources['basemaps-aerial'];
+    const aerialSource = body.sources['basemaps-aerial'] as unknown as SourceRaster;
 
-    assert.equal(body.version, 8);
-    assert.deepEqual(body.sources['basemaps-aerial'].type, 'raster');
-    assert.deepEqual(body.sources['basemaps-aerial'].tiles, [
+    assert.deepEqual(aerialSource.type, 'raster');
+    assert.deepEqual(aerialSource.tiles, [
       `https://tiles.test/v1/tiles/aerial/WebMercatorQuad/{z}/{x}/{y}.webp?api=${Api.key}&config=${configId}`,
     ]);
-    assert.deepEqual(body.sources['basemaps-aerial'].tileSize, 256);
+    assert.deepEqual(aerialSource.tileSize, 256);
     assert.deepEqual(body.layers, [{ id: 'basemaps-aerial', type: 'raster', source: 'basemaps-aerial' }]);
   });
+
+  it('should create individual raster styles with terrain', async () => {
+    const configId = FakeData.bundle([FakeData.tileSetRaster('christchurch-urban-2020-2021-0.075m'), TileSetElevation]);
+    const request = mockUrlRequest(
+      '/v1/styles/christchurch-urban-2020-2021-0.075m.json',
+      `?config=${configId}`,
+      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;
+
+    assert.equal(body.version, 8);
+    const rasterSource = body.sources['basemaps-christchurch-urban-2020-2021-0.075m'] as unknown as SourceRaster;
+
+    assert.deepEqual(rasterSource.type, 'raster');
+    assert.deepEqual(rasterSource.tiles, [
+      `https://tiles.test/v1/tiles/christchurch-urban-2020-2021-0.075m/WebMercatorQuad/{z}/{x}/{y}.webp?api=${Api.key}&config=${configId}`,
+    ]);
+    assert.deepEqual(rasterSource.tileSize, 256);
+    assert.deepEqual(body.layers, [
+      {
+        id: 'basemaps-christchurch-urban-2020-2021-0.075m',
+        type: 'raster',
+        source: 'basemaps-christchurch-urban-2020-2021-0.075m',
+      },
+    ]);
+
+    const rasterDemSource = body.sources['LINZ-Terrain'] as unknown as SourceRaster;
+
+    assert.deepEqual(rasterDemSource.type, 'raster-dem');
+    assert.deepEqual(rasterDemSource.tiles, [
+      `https://tiles.test/v1/tiles/elevation/WebMercatorQuad/{z}/{x}/{y}.png?api=${Api.key}&config=${configId}&pipeline=terrain-rgb`,
+    ]);
+  });
+
+  const fakeVectorStyleConfig = {
+    id: 'test',
+    name: 'test',
+    sources: {
+      basemaps_vector: {
+        type: 'vector',
+        url: `/vector`,
+      },
+    },
+    layers: [
+      {
+        layout: {
+          visibility: 'visible',
+        },
+        paint: {
+          'background-color': 'rgba(206, 229, 242, 1)',
+        },
+        id: 'Background1',
+        type: 'background',
+        minzoom: 0,
+      },
+    ],
+  };
+
+  const fakeVectorRecord = {
+    id: 'st_topolite',
+    name: 'topolite',
+    style: fakeVectorStyleConfig,
+  };
+
+  it('should ensure terrain for all style config', async () => {
+    const request = mockUrlRequest('/v1/styles/topolite.json', '?terrain=LINZ-Terrain', Api.header);
+    config.put(fakeVectorRecord);
+    config.put(TileSetElevation);
+
+    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 rasterDemSource = body.sources['LINZ-Terrain'] as unknown as SourceRaster;
+
+    assert.deepEqual(rasterDemSource.type, 'raster-dem');
+    assert.deepEqual(rasterDemSource.tiles, [
+      `https://tiles.test/v1/tiles/elevation/WebMercatorQuad/{z}/{x}/{y}.png?api=${Api.key}&pipeline=terrain-rgb`,
+    ]);
+  });
+
+  const fakeAerialStyleConfig = {
+    id: 'test',
+    name: 'test',
+    sources: {
+      basemaps_raster: {
+        type: 'raster',
+        tiles: [`/raster/{z}/{x}/{y}.webp`],
+      },
+      basemaps_terrain: {
+        type: 'raster-dem',
+        tiles: [`/elevation/{z}/{x}/{y}.png?pipeline=terrain-rgb`],
+      },
+    },
+    layers: [
+      {
+        layout: {
+          visibility: 'visible',
+        },
+        paint: {
+          'background-color': 'rgba(206, 229, 242, 1)',
+        },
+        id: 'Background1',
+        type: 'background',
+        minzoom: 0,
+      },
+    ],
+  };
+
+  const fakeAerialRecord = {
+    id: 'st_aerial',
+    name: 'aerial',
+    style: fakeAerialStyleConfig,
+  };
+
+  it('should set terrain via parameter for style config', async () => {
+    const request = mockUrlRequest('/v1/styles/aerial.json', '?terrain=basemaps_terrain', Api.header);
+    config.put(fakeAerialRecord);
+    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, 'basemaps_terrain');
+    assert.deepEqual(terrain.exaggeration, 1.2);
+  });
+
+  it('should set terrain via parameter for tileSet config', async () => {
+    config.put(TileSetAerial);
+    config.put(TileSetElevation);
+    const request = mockUrlRequest('/v1/styles/aerial.json', `?terrain=LINZ-Terrain`, 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);
+  });
 });

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

@@ -4,7 +4,7 @@ import { afterEach, beforeEach, describe, it } from 'node:test';
 import { ConfigProviderMemory, ConfigTileSetRaster } from '@basemaps/config';
 import { Env } from '@basemaps/shared';
 
-import { Imagery2193, Imagery3857, Provider, TileSetAerial } from '../../__tests__/config.data.js';
+import { Imagery2193, Imagery3857, Provider, TileSetAerial, TileSetElevation } from '../../__tests__/config.data.js';
 import { Api, mockUrlRequest } from '../../__tests__/xyz.util.js';
 import { handler } from '../../index.js';
 import { ConfigLoader } from '../../util/config.loader.js';
@@ -27,6 +27,28 @@ describe('WMTSRouting', () => {
     config.objects.clear();
   });
 
+  it('should support pipeline', async (t) => {
+    t.mock.method(Env, 'get', (arg: string) => {
+      if (arg === Env.PublicUrlBase) return 'https://tiles.test';
+      return process.env[arg];
+    });
+    config.put(TileSetElevation);
+    t.mock.method(ConfigLoader, 'load', () => Promise.resolve(config));
+    const req = mockUrlRequest(
+      '/v1/tiles/elevation/WebMercatorQuad/WMTSCapabilities.xml',
+      `tileFormat=png&api=${Api.key}&config=s3://linz-basemaps/config.json&pipeline=terrain-rgb`,
+    );
+    const res = await handler.router.handle(req);
+
+    assert.equal(res.status, 200);
+    const lines = Buffer.from(res.body, 'base64').toString().split('\n');
+    const resourceUrl = lines.find((f) => f.includes('ResourceURL'))?.trim();
+
+    assert.ok(resourceUrl);
+    assert.ok(resourceUrl.includes('amp;pipeline=terrain-rgb'), `includes pipeline=terrain-rgb in ${resourceUrl}`);
+    assert.ok(resourceUrl.includes('.png'), `includes .png in ${resourceUrl}`);
+  });
+
   it('should default to the aerial layer', async (t) => {
     t.mock.method(Env, 'get', (arg: string) => {
       if (arg === Env.PublicUrlBase) return 'https://tiles.test';
@@ -68,8 +90,6 @@ describe('WMTSRouting', () => {
 
     config.put({ ...TileSetAerial, id: 'ts_all', name: 'all', layers: [] } as ConfigTileSetRaster);
 
-    config.createVirtualTileSets;
-
     const req = mockUrlRequest(
       '/v1/tiles/all/WMTSCapabilities.xml',
       `format=png&api=${Api.key}&config=s3://linz-basemaps/config.json`,

package/src/routes/config.ts

@@ -6,7 +6,7 @@ import { ConfigLoader } from '../util/config.loader.js';
 import { Etag } from '../util/etag.js';
 import { NotFound, NotModified } from '../util/response.js';
 
-async function sendJson(req: LambdaHttpRequest, toSend: unknown): Promise<LambdaHttpResponse> {
+function sendJson(req: LambdaHttpRequest, toSend: unknown): LambdaHttpResponse {
   const data = Buffer.from(JSON.stringify(toSend));
 
   const cacheKey = Etag.key(data);

package/src/routes/ping.ts

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

package/src/routes/preview.index.ts

@@ -1,6 +1,7 @@
 import { promisify } from 'node:util';
 import { gunzip } from 'node:zlib';
 
+import { TileSetType } from '@basemaps/config';
 import { GoogleTms, LocationUrl, LonLatZoom, TileMatrixSets } from '@basemaps/geo';
 import { Env, fsa, getPreviewQuery } from '@basemaps/shared';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
@@ -95,7 +96,7 @@ export async function previewIndexGet(req: LambdaHttpRequest<PreviewIndexGet>):
   const tileSet = await config.TileSet.get(config.TileSet.id(query.style));
   req.timer.end('tileset:load');
   if (tileSet == null) return loadAndServeIndexHtml(req, loc);
-  if (tileSet.type !== 'raster') return loadAndServeIndexHtml(req, loc);
+  if (tileSet.type !== TileSetType.Raster) return loadAndServeIndexHtml(req, loc);
 
   let tileMatrix = TileMatrixSets.find(query.tileMatrix);
   if (tileMatrix == null) tileMatrix = GoogleTms;

package/src/routes/preview.ts

@@ -1,4 +1,4 @@
-import { ConfigTileSetRaster, ConfigTileSetRasterOutput } from '@basemaps/config';
+import { ConfigTileSetRaster, ConfigTileSetRasterOutput, TileSetType } from '@basemaps/config';
 import { Bounds, LatLon, Projection, TileMatrixSet } from '@basemaps/geo';
 import { CompositionTiff, TileMakerContext, Tiler } from '@basemaps/tiler';
 import { SharpOverlay, TileMakerSharp } from '@basemaps/tiler-sharp';
@@ -62,7 +62,7 @@ export async function tilePreviewGet(req: LambdaHttpRequest<PreviewGet>): Promis
   req.timer.end('tileset:load');
   if (tileSet == null) return new LambdaHttpResponse(404, 'Tileset not found');
   // Only raster previews are supported
-  if (tileSet.type !== 'raster') return new LambdaHttpResponse(404, 'Preview invalid tile set type');
+  if (tileSet.type !== TileSetType.Raster) return new LambdaHttpResponse(404, 'Preview invalid tile set type');
 
   const pipeline = req.query.get('pipeline');
 
@@ -161,6 +161,8 @@ export async function renderPreview(req: LambdaHttpRequest, ctx: PreviewRenderCo
 
   // Load all the tiff tiles and resize/them into the correct locations
   req.timer.start('compose:overlay');
+  // Remove with typescript >=5.5.0
+
   const overlays = (await Promise.all(
     compositions.map((comp) => {
       if (tileContext.pipeline) return TilerSharp.composeTilePipeline(comp, tileContext);

package/src/routes/sprites.ts

@@ -10,7 +10,7 @@ interface SpriteGet {
   };
 }
 
-const Extensions = new Map();
+const Extensions = new Map<string, string>();
 Extensions.set('.png', 'image/png');
 Extensions.set('.json', 'application/json');