@basemaps/lambda-tiler 7.4.0 → 7.6.0

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,7 +1,7 @@
-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';
+import { TileMakerSharp } from '@basemaps/tiler-sharp';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import sharp from '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,12 +161,14 @@ 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');
-  const overlays = (await Promise.all(
+  // Remove with typescript >=5.5.0
+
+  const overlays = await Promise.all(
     compositions.map((comp) => {
       if (tileContext.pipeline) return TilerSharp.composeTilePipeline(comp, tileContext);
       return TilerSharp.composeTileTiff(comp, tileContext.resizeKernel);
     }),
-  ).then((items) => items.filter((f) => f != null))) as SharpOverlay[];
+  ).then((items) => items.filter((f) => f != null));
   req.timer.end('compose:overlay');
 
   // Create the output image and render all the individual pieces into them

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');
 

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

@@ -1,4 +1,4 @@
-import { ConfigTileSetRaster, Layer, Sources, StyleJson, TileSetType } from '@basemaps/config';
+import { ConfigId, ConfigPrefix, ConfigTileSetRaster, Layer, Sources, StyleJson, TileSetType } from '@basemaps/config';
 import { GoogleTms, TileMatrixSet, TileMatrixSets } from '@basemaps/geo';
 import { Env, toQueryString } from '@basemaps/shared';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
@@ -44,10 +44,12 @@ export function convertStyleJson(
   config: string | null,
   layers?: Layer[],
 ): StyleJson {
-  const sources: Sources = JSON.parse(JSON.stringify(style.sources));
+  const sources = JSON.parse(JSON.stringify(style.sources)) as Sources;
   for (const [key, value] of Object.entries(sources)) {
     if (value.type === 'vector') {
-      if (tileMatrix !== GoogleTms) throw new Error(`TileMatrix is not supported for the vector source ${value.url}.`);
+      if (tileMatrix !== GoogleTms) {
+        throw new LambdaHttpResponse(400, `TileMatrix is not supported for the vector source ${value.url}.`);
+      }
       value.url = convertRelativeUrl(value.url, tileMatrix, apiKey, config);
     } else if ((value.type === 'raster' || value.type === 'raster-dem') && Array.isArray(value.tiles)) {
       for (let i = 0; i < value.tiles.length; i++) {
@@ -68,6 +70,7 @@ export function convertStyleJson(
   if (style.metadata) styleJson.metadata = style.metadata;
   if (style.glyphs) styleJson.glyphs = convertRelativeUrl(style.glyphs, undefined, undefined, config);
   if (style.sprite) styleJson.sprite = convertRelativeUrl(style.sprite, undefined, undefined, config);
+  if (style.sky) styleJson.sky = style.sky;
 
   return styleJson;
 }
@@ -78,11 +81,41 @@ export interface StyleGet {
   };
 }
 
+function setStyleTerrain(style: StyleJson, terrain: string): void {
+  const source = Object.keys(style.sources).find((s) => s === terrain);
+  if (source == null) throw new LambdaHttpResponse(400, `Terrain: ${terrain} is not exists in the style source.`);
+  style.terrain = {
+    source,
+    exaggeration: 1.2,
+  };
+}
+
+async function ensureTerrain(
+  req: LambdaHttpRequest<StyleGet>,
+  tileMatrix: TileMatrixSet,
+  apiKey: string,
+  style: StyleJson,
+): Promise<void> {
+  const config = await ConfigLoader.load(req);
+  const terrain = await config.TileSet.get('ts_elevation');
+  if (terrain) {
+    const configLocation = ConfigLoader.extract(req);
+    const elevationQuery = toQueryString({ config: configLocation, api: apiKey, pipeline: 'terrain-rgb' });
+    style.sources['LINZ-Terrain'] = {
+      type: 'raster-dem',
+      tileSize: 256,
+      maxzoom: 18,
+      tiles: [convertRelativeUrl(`/v1/tiles/elevation/${tileMatrix.identifier}/{z}/{x}/{y}.png${elevationQuery}`)],
+    };
+  }
+}
+
 export async function tileSetToStyle(
   req: LambdaHttpRequest<StyleGet>,
   tileSet: ConfigTileSetRaster,
   tileMatrix: TileMatrixSet,
   apiKey: string,
+  terrain?: string,
 ): Promise<LambdaHttpResponse> {
   const [tileFormat] = Validate.getRequestedFormats(req) ?? ['webp'];
   if (tileFormat == null) return new LambdaHttpResponse(400, 'Invalid image format');
@@ -98,11 +131,20 @@ export async function tileSetToStyle(
     `/v1/tiles/${tileSet.name}/${tileMatrix.identifier}/{z}/{x}/{y}.${tileFormat}${query}`;
 
   const styleId = `basemaps-${tileSet.name}`;
-  const style = {
+  const style: StyleJson = {
+    id: ConfigId.prefix(ConfigPrefix.Style, tileSet.name),
+    name: tileSet.name,
     version: 8,
     sources: { [styleId]: { type: 'raster', tiles: [tileUrl], tileSize: 256 } },
     layers: [{ id: styleId, type: 'raster', source: styleId }],
   };
+
+  // Ensure elevation for individual tilesets
+  await ensureTerrain(req, tileMatrix, apiKey, style);
+
+  // Add terrain in style
+  if (terrain) setStyleTerrain(style, terrain);
+
   const data = Buffer.from(JSON.stringify(style));
 
   const cacheKey = Etag.key(data);
@@ -121,6 +163,7 @@ export async function tileSetOutputToStyle(
   tileSet: ConfigTileSetRaster,
   tileMatrix: TileMatrixSet,
   apiKey: string,
+  terrain?: string,
 ): Promise<LambdaHttpResponse> {
   const configLocation = ConfigLoader.extract(req);
   const query = toQueryString({ config: configLocation, api: apiKey });
@@ -171,19 +214,31 @@ export async function tileSetOutputToStyle(
     }
   }
 
-  const style = { version: 8, sources, layers };
+  const style: StyleJson = {
+    id: ConfigId.prefix(ConfigPrefix.Style, tileSet.name),
+    name: tileSet.name,
+    version: 8,
+    sources,
+    layers,
+  };
+
+  // Ensure elevation for style json config
+  await ensureTerrain(req, tileMatrix, apiKey, style);
+
+  // Add terrain in style
+  if (terrain) setStyleTerrain(style, terrain);
 
   const data = Buffer.from(JSON.stringify(style));
 
   const cacheKey = Etag.key(data);
-  if (Etag.isNotModified(req, cacheKey)) return NotModified();
+  if (Etag.isNotModified(req, cacheKey)) return Promise.resolve(NotModified());
 
   const response = new LambdaHttpResponse(200, 'ok');
   response.header(HttpHeader.ETag, cacheKey);
   response.header(HttpHeader.CacheControl, 'no-store');
   response.buffer(data, 'application/json');
   req.set('bytes', data.byteLength);
-  return response;
+  return Promise.resolve(response);
 }
 
 export async function styleJsonGet(req: LambdaHttpRequest<StyleGet>): Promise<LambdaHttpResponse> {
@@ -193,6 +248,7 @@ export async function styleJsonGet(req: LambdaHttpRequest<StyleGet>): Promise<La
   const excluded = new Set(excludeLayers.map((l) => l.toLowerCase()));
   const tileMatrix = TileMatrixSets.find(req.query.get('tileMatrix') ?? GoogleTms.identifier);
   if (tileMatrix == null) return new LambdaHttpResponse(400, 'Invalid tile matrix');
+  const terrain = req.query.get('terrain') ?? undefined;
 
   // Get style Config from db
   const config = await ConfigLoader.load(req);
@@ -203,8 +259,8 @@ export async function styleJsonGet(req: LambdaHttpRequest<StyleGet>): Promise<La
     const tileSet = await config.TileSet.get(config.TileSet.id(styleName));
     if (tileSet == null) return NotFound();
     if (tileSet.type !== TileSetType.Raster) return NotFound();
-    if (tileSet.outputs) return tileSetOutputToStyle(req, tileSet, tileMatrix, apiKey);
-    else return tileSetToStyle(req, tileSet, tileMatrix, apiKey);
+    if (tileSet.outputs) return await tileSetOutputToStyle(req, tileSet, tileMatrix, apiKey, terrain);
+    else return await tileSetToStyle(req, tileSet, tileMatrix, apiKey, terrain);
   }
 
   // Prepare sources and add linz source
@@ -215,6 +271,14 @@ export async function styleJsonGet(req: LambdaHttpRequest<StyleGet>): Promise<La
     ConfigLoader.extract(req),
     styleConfig.style.layers.filter((f) => !excluded.has(f.id.toLowerCase())),
   );
+
+  // Ensure elevation for style json config
+  // TODO: We should remove this after adding terrain source into style configs. PR-916
+  await ensureTerrain(req, tileMatrix, apiKey, style);
+
+  // Add terrain in style
+  if (terrain) setStyleTerrain(style, terrain);
+
   const data = Buffer.from(JSON.stringify(style));
 
   const cacheKey = Etag.key(data);

package/src/routes/tile.wmts.ts

@@ -69,6 +69,7 @@ export async function wmtsCapabilitiesGet(req: LambdaHttpRequest<WmtsCapabilitie
     imagery,
     formats: Validate.getRequestedFormats(req) ?? [],
     layers: req.params.tileMatrix == null ? tileSet.layers : undefined,
+    pipeline: req.query.get('pipeline'),
   });
 
   const xml = wmts.toXml();

package/src/routes/tile.xyz.raster.ts

@@ -95,20 +95,22 @@ export const TileXyzRaster = {
       toLoad.push(
         LoadingQueue((): Promise<CloudArchive | null> => {
           if (assetPath.pathname.endsWith('.tar.co')) {
-            return CoSources.getCotar(assetPath).catch((error) => {
-              req.log.warn({ error, tiff: assetPath }, 'Load:Cotar:Failed');
+            return CoSources.getCotar(assetPath).catch((err: unknown) => {
+              req.log.warn({ err, tiff: assetPath }, 'Load:Cotar:Failed');
               return null;
             });
           }
-          return CoSources.getCog(assetPath).catch((error) => {
-            req.log.warn({ error, tiff: assetPath }, 'Load:Tiff:Failed');
+          return CoSources.getCog(assetPath).catch((err: unknown) => {
+            req.log.warn({ err, tiff: assetPath }, 'Load:Tiff:Failed');
             return null;
           });
         }),
       );
     }
 
-    return (await Promise.all(toLoad)).filter((f) => f != null) as CloudArchive[];
+    // Remove with typescript >=5.5.0
+
+    return (await Promise.all(toLoad)).filter((f) => f != null);
   },
 
   async getAssetsForTile(req: LambdaHttpRequest, tileSet: ConfigTileSetRaster, xyz: TileXyz): Promise<URL[]> {
@@ -128,7 +130,7 @@ export const TileXyzRaster = {
     const assets = await TileXyzRaster.loadAssets(req, assetPaths);
 
     const tiler = new Tiler(xyz.tileMatrix);
-    const layers = await tiler.tile(assets, xyz.tile.x, xyz.tile.y, xyz.tile.z);
+    const layers = tiler.tile(assets, xyz.tile.x, xyz.tile.y, xyz.tile.z);
 
     const format = getImageFormat(xyz.tileType);
     if (format == null) return new LambdaHttpResponse(400, 'Invalid image format: ' + xyz.tileType);

package/src/routes/version.ts

@@ -1,6 +1,6 @@
 import { HttpHeader, LambdaHttpResponse } from '@linzjs/lambda';
 
-export async function versionGet(): Promise<LambdaHttpResponse> {
+export function versionGet(): Promise<LambdaHttpResponse> {
   const response = new LambdaHttpResponse(200, 'ok');
   response.header(HttpHeader.CacheControl, 'no-store');
   response.json({
@@ -20,5 +20,5 @@ export async function versionGet(): Promise<LambdaHttpResponse> {
      */
     buildId: process.env['BUILD_ID'],
   });
-  return response;
+  return Promise.resolve(response);
 }