@basemaps/lambda-tiler 8.11.1 → 8.13.0

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

@@ -20,19 +20,95 @@ describe('/v1/styles', () => {
   before(() => {
     process.env[Env.PublicUrlBase] = host;
   });
+
   beforeEach(() => {
     sandbox.stub(ConfigLoader, 'getDefaultConfig').resolves(config);
   });
+
   afterEach(() => {
     sandbox.restore();
     config.objects.clear();
   });
+
   it('should not found style json', async () => {
     const request = mockRequest('/v1/tiles/topographic/Google/style/topographic.json', 'get', Api.header);
     const res = await handler.router.handle(request);
     assert.equal(res.status, 404);
   });
 
+  it('should select default layers', async () => {
+    config.put(TileSetElevation);
+
+    const request = mockRequest('/v1/styles/elevation.json', 'get', Api.header);
+    const res = await handler.router.handle(request);
+    // No default set so this should 404
+    assert.equal(res.status, 404, res.statusDescription);
+
+    // Setting a default of color-ramp
+    const ts = structuredClone(TileSetElevation);
+    ts.outputs![1].default = true;
+    config.put(ts);
+
+    const resB = await handler.router.handle(request);
+    assert.equal(resB.status, 200, resB.statusDescription);
+    const body = JSON.parse(Buffer.from(resB.body, 'base64').toString()) as StyleJson;
+    assert.equal(body.layers[0].source, 'basemaps-elevation-color-ramp');
+  });
+
+  it('should select default layers', async () => {
+    const request = mockRequest('/v1/styles/elevation.json', 'get', Api.header);
+
+    // Setting a default of color-ramp
+    const ts = structuredClone(TileSetElevation);
+    ts.outputs![0].default = true;
+    config.put(ts);
+
+    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.layers[0].source, 'basemaps-elevation-terrain-rgb');
+    assert.deepEqual(Object.keys(body.sources), [
+      'basemaps-elevation-terrain-rgb',
+      'basemaps-elevation-terrain-rgb-dem',
+      'basemaps-elevation-color-ramp',
+      'LINZ-Terrain',
+    ]);
+  });
+
+  it('should request the tile format if possible', async () => {
+    const request = mockUrlRequest('/v1/styles/elevation.json', `?tileFormat=avif&api=${Api.key}`);
+
+    // Setting a default of color-ramp
+    const ts = structuredClone(TileSetElevation);
+    ts.outputs![1].default = true;
+    config.put(ts);
+
+    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 sources = Object.values(body.sources).map((s) =>
+      (s as SourceRaster).tiles?.[0].replace(`api=${Api.key}`, ''),
+    );
+
+    // Requested avif from a dataset that has terrain-rgb,
+    // terrain-rgb has to be served as png,
+    // but color-ramp can be served as avif
+    assert.deepEqual(sources, [
+      'https://tiles.test/v1/tiles/elevation/WebMercatorQuad/{z}/{x}/{y}.png?&pipeline=terrain-rgb',
+      'https://tiles.test/v1/tiles/elevation/WebMercatorQuad/{z}/{x}/{y}.png?&pipeline=terrain-rgb',
+      'https://tiles.test/v1/tiles/elevation/WebMercatorQuad/{z}/{x}/{y}.avif?&pipeline=color-ramp',
+      'https://tiles.test/v1/tiles/elevation/WebMercatorQuad/{z}/{x}/{y}.png?&pipeline=terrain-rgb',
+    ]);
+
+    // as terrain rgb cannot be output as avif, if it is specifically requested error
+    const requestB = mockUrlRequest(
+      '/v1/styles/elevation.json',
+      `?tileFormat=avif&api=${Api.key}&pipeline=terrain-rgb`,
+    );
+    const resB = await handler.router.handle(requestB);
+    assert.equal(resB.status, 400, res.statusDescription);
+  });
+
   const fakeStyle: StyleJson = {
     version: 8,
     id: 'test',
@@ -119,32 +195,16 @@ describe('/v1/styles', () => {
     assert.equal(res.header('content-type'), 'application/json');
     assert.equal(res.header('cache-control'), 'no-store');
 
-    const body = Buffer.from(res.body ?? '', 'base64').toString();
-    fakeStyle.sources['basemaps_vector'] = {
-      type: 'vector',
-      url: `${host}/vector?api=${Api.key}`,
-    };
-    fakeStyle.sources['basemaps_raster'] = {
-      type: 'raster',
-      tiles: [`${host}/raster?api=${Api.key}`],
-    };
-    fakeStyle.sources['basemaps_raster_encode'] = {
-      type: 'raster',
-      tiles: [`${host}/raster/{z}/{x}/{y}.webp?api=${Api.key}`],
-    };
+    const targetStyle = JSON.parse(Buffer.from(res.body ?? '', 'base64').toString()) as StyleJson;
 
-    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`;
-
-    assert.deepEqual(JSON.parse(body), fakeStyle);
+    assert.deepEqual(targetStyle.layers, fakeStyle.layers);
+    assert.deepEqual(Object.keys(targetStyle.sources), Object.keys(fakeStyle.sources));
+    assert.equal(targetStyle.glyphs, `${host}${fakeStyle.glyphs}`);
+    assert.equal(targetStyle.sprite, `${host}${fakeStyle.sprite}`);
   });
 
   it('should serve style json with excluded layers', async () => {
+    console.log(fakeRecord.style.layers.map((m) => m.id));
     config.put(fakeRecord);
     const request = mockUrlRequest(
       '/v1/tiles/topographic/Google/style/topographic.json',
@@ -157,25 +217,18 @@ describe('/v1/styles', () => {
     assert.equal(res.header('content-type'), 'application/json');
     assert.equal(res.header('cache-control'), 'no-store');
 
-    const body = Buffer.from(res.body ?? '', 'base64').toString();
-    fakeStyle.sources['basemaps_vector'] = {
-      type: 'vector',
-      url: `${host}/vector?api=${Api.key}`,
-    };
-    fakeStyle.sources['basemaps_raster'] = {
-      type: 'raster',
-      tiles: [`${host}/raster?api=${Api.key}`],
-    };
-    fakeStyle.sources['basemaps_raster_encode'] = {
-      type: 'raster',
-      tiles: [`${host}/raster/{z}/{x}/{y}.webp?api=${Api.key}`],
-    };
-
-    fakeStyle.sprite = `${host}/sprite`;
-    fakeStyle.glyphs = `${host}/glyphs`;
-    fakeStyle.layers = [fakeStyle.layers[2]];
+    const targetStyle = JSON.parse(Buffer.from(res.body ?? '', 'base64').toString()) as StyleJson;
+    assert.deepEqual(
+      targetStyle.layers.map((m) => m.id),
+      ['Background3'],
+    );
+    // original record should be preserved
+    assert.deepEqual(
+      fakeRecord.style.layers.map((m) => m.id),
+      ['Background1', 'Background2', 'Background3'],
+    );
 
-    assert.deepEqual(JSON.parse(body), fakeStyle);
+    assert.deepEqual(Object.keys(targetStyle.sources), Object.keys(fakeStyle.sources));
   });
 
   it('should create raster styles', async () => {
@@ -295,6 +348,7 @@ describe('/v1/styles', () => {
         },
         id: 'Background1',
         type: 'background',
+        source: 'basemaps_vector',
         minzoom: 0,
       },
     ],
@@ -323,6 +377,63 @@ describe('/v1/styles', () => {
     ]);
   });
 
+  describe('style.merge', () => {
+    it('should merge terrain for all style config', async () => {
+      const request = mockUrlRequest('/v1/styles/aerial,topolite.json', '', Api.header);
+      config.put(fakeVectorRecord);
+      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 aerialSource = body.sources['basemaps_raster'] as unknown as SourceRaster;
+
+      assert.equal(aerialSource.type, 'raster');
+      assert.equal(body.layers[0].source, 'basemaps_raster');
+      assert.equal(body.layers[1].source, 'basemaps_vector');
+    });
+
+    it('should fail merge terrain for duplicate layers', async () => {
+      const request = mockUrlRequest('/v1/styles/topolite,topolite.json', '', Api.header);
+      config.put(fakeVectorRecord);
+
+      const res = await handler.router.handle(request);
+
+      assert.equal(res.status, 400, res.statusDescription);
+      assert.equal(res.statusDescription.includes('duplicate layerIds'), true);
+    });
+
+    it('should fail merge terrain for large requests', async () => {
+      const layers = 'topolite,'.repeat(10).slice(0, -1);
+      const request = mockUrlRequest(`/v1/styles/${layers}.json`, '', Api.header);
+      config.put(fakeVectorRecord);
+
+      const res = await handler.router.handle(request);
+      assert.equal(res.status, 400, res.statusDescription);
+      assert.equal(res.statusDescription.includes('Too many styles'), true);
+    });
+
+    it('should skip merging empty style names', async () => {
+      const layers = ','.repeat(10);
+      const request = mockUrlRequest(`/v1/styles/${layers}topolite.json`, '', Api.header);
+      config.put(fakeVectorRecord);
+
+      const res = await handler.router.handle(request);
+      assert.equal(res.status, 200, res.statusDescription);
+      console.log(request.url);
+    });
+
+    it('should fail merge if one layer is missing', async () => {
+      const request = mockUrlRequest('/v1/styles/topolite,missing-layer.json', '', Api.header);
+      config.put(fakeVectorRecord);
+
+      const res = await handler.router.handle(request);
+
+      assert.equal(res.status, 404, res.statusDescription);
+    });
+  });
+
   const fakeAerialStyleConfig = {
     id: 'test',
     name: 'test',
@@ -344,8 +455,9 @@ describe('/v1/styles', () => {
         paint: {
           'background-color': 'rgba(206, 229, 242, 1)',
         },
-        id: 'Background1',
-        type: 'background',
+        id: 'aerial',
+        source: 'basemaps_raster',
+        type: 'raster',
         minzoom: 0,
       },
     ],

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

@@ -4,7 +4,15 @@ import { afterEach, beforeEach, describe, it } from 'node:test';
 import { ConfigProviderMemory, ConfigTileSetRaster } from '@basemaps/config';
 import { Env } from '@basemaps/shared';
 
-import { Imagery2193, Imagery3857, Provider, TileSetAerial, TileSetElevation } from '../../__tests__/config.data.js';
+import {
+  Imagery2193,
+  Imagery2193Elevation,
+  Imagery3857,
+  Imagery3857Elevation,
+  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';
@@ -33,6 +41,8 @@ describe('WMTSRouting', () => {
       return process.env[arg];
     });
     config.put(TileSetElevation);
+    config.put(Imagery2193Elevation);
+    config.put(Imagery3857Elevation);
     t.mock.method(ConfigLoader, 'load', () => Promise.resolve(config));
     const req = mockUrlRequest(
       '/v1/tiles/elevation/WebMercatorQuad/WMTSCapabilities.xml',
@@ -42,9 +52,10 @@ describe('WMTSRouting', () => {
 
     assert.equal(res.status, 200);
     const lines = Buffer.from(res.body, 'base64').toString().split('\n');
-    const resourceUrl = lines.find((f) => f.includes('ResourceURL'))?.trim();
+    const resourceUrls = lines.filter((f) => f.includes('ResourceURL'));
 
-    assert.ok(resourceUrl);
+    const resourceUrl = resourceUrls[0].trim();
+    assert.equal(resourceUrls.length, 1);
     assert.ok(resourceUrl.includes('amp;pipeline=terrain-rgb'), `includes pipeline=terrain-rgb in ${resourceUrl}`);
     assert.ok(resourceUrl.includes('.png'), `includes .png in ${resourceUrl}`);
   });

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

@@ -205,7 +205,7 @@ describe('/v1/tiles', () => {
     elevation.outputs = [{ title: 'Terrain RGB', name: 'terrain-rgb' }];
     config.put(elevation);
 
-    // JPEG is not lossless
+    // pbf is not a imagery format
     const resPbf = await handler.router.handle(
       mockUrlRequest('/v1/tiles/elevation/3857/11/2022/1283.pbf', '?pipeline=terrain-rgb', Api.header),
     );

package/src/routes/preview.ts

@@ -64,23 +64,11 @@ export async function tilePreviewGet(req: LambdaHttpRequest<PreviewGet>): Promis
   // Only raster previews are supported
   if (tileSet.type !== TileSetType.Raster) return new LambdaHttpResponse(404, 'Preview invalid tile set type');
 
-  const pipeline = req.query.get('pipeline');
+  const { output, format } = Validate.pipeline(tileSet, req.params.outputType, req.query.get('pipeline'));
+  req.set('extension', format);
+  req.set('pipeline', output.name);
 
-  // Use the prefered output format from the pipeline if its defined
-  let defaultFormat = 'webp';
-  if (pipeline) {
-    const output = tileSet.outputs?.find((f) => f.name === pipeline);
-    defaultFormat = output?.format?.[0] ?? defaultFormat;
-  }
-
-  const outputFormat = req.params.outputType ?? defaultFormat;
-
-  const tileOutput = Validate.pipeline(tileSet, outputFormat, req.query.get('pipeline'));
-  if (tileOutput == null) return new LambdaHttpResponse(404, `Output format: ${outputFormat} not found`);
-  req.set('extension', outputFormat);
-  req.set('pipeline', tileOutput.name ?? 'rgba');
-
-  return renderPreview(req, { tileSet, tileMatrix, location, output: tileOutput, z });
+  return renderPreview(req, { tileSet, tileMatrix, location, output, z });
 }
 
 interface PreviewRenderContext {

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

@@ -173,18 +173,22 @@ export async function tileSetToStyle(
   // If the style has outputs defined it has a different process for generating the stylejson
   if (tileSet.outputs) return tileSetOutputToStyle(req, tileSet, tileMatrix, apiKey);
 
-  const [tileFormat] = Validate.getRequestedFormats(req) ?? ['webp'];
-  if (tileFormat == null) throw new LambdaHttpResponse(400, 'Invalid image format');
-
-  const pipeline = Validate.pipeline(tileSet, tileFormat, req.query.get('pipeline'));
-  const pipelineName = pipeline?.name === 'rgba' ? undefined : pipeline?.name;
+  const { output, format } = Validate.pipeline(
+    tileSet,
+    Validate.getRequestedFormats(req)?.[0],
+    req.query.get('pipeline'),
+  );
 
   const configLocation = ConfigLoader.extract(req);
-  const query = toQueryString({ config: configLocation, api: apiKey, pipeline: pipelineName });
+  const query = toQueryString({
+    config: configLocation,
+    api: apiKey,
+    pipeline: output.name === 'rgba' ? undefined : '',
+  });
 
   const tileUrl =
     (Env.get(Env.PublicUrlBase) ?? '') +
-    `/v1/tiles/${tileSet.name}/${tileMatrix.identifier}/{z}/{x}/{y}.${tileFormat}${query}`;
+    `/v1/tiles/${tileSet.name}/${tileMatrix.identifier}/{z}/{x}/{y}.${format}${query}`;
 
   const attribution = await createTileSetAttribution(config, tileSet, tileMatrix.projection);
 
@@ -221,12 +225,21 @@ export function tileSetOutputToStyle(
   const sources: Sources = {};
   const layers: Layer[] = [];
 
+  const requestedFormat = Validate.getRequestedFormats(req)?.[0];
+  const { output, format } = Validate.pipeline(tileSet, requestedFormat, req.query.get('pipeline'));
+
   for (const output of tileSet.outputs) {
-    const format = output.format?.[0] ?? 'webp';
+    let imageFormat = requestedFormat ?? 'webp';
+    // If a image format is requested, try and use the requested format
+    if (output.format) {
+      if (output.format.includes(format)) imageFormat = format;
+      else imageFormat = output.format[0];
+    }
+    // const imageFormat = output.format ?  output.format?.includes(format) ? format : output.format?.[0]
     const urlBase = Env.get(Env.PublicUrlBase) ?? '';
     const query = toQueryString({ config: configLocation, api: apiKey, pipeline: output.name });
 
-    const tileUrl = `${urlBase}/v1/tiles/${tileSet.name}/${tileMatrix.identifier}/{z}/{x}/{y}.${format}${query}`;
+    const tileUrl = `${urlBase}/v1/tiles/${tileSet.name}/${tileMatrix.identifier}/{z}/{x}/{y}.${imageFormat}${query}`;
 
     if (output.name === 'terrain-rgb') {
       // Add both raster source and dem raster source for terrain-rgb output
@@ -238,11 +251,7 @@ export function tileSetOutputToStyle(
     }
   }
 
-  const [tileFormat] = Validate.getRequestedFormats(req) ?? ['webp'];
-  if (tileFormat == null) throw new LambdaHttpResponse(400, 'Invalid image format');
-
-  const pipeline = Validate.pipeline(tileSet, tileFormat, req.query.get('pipeline'));
-  const pipelineName = pipeline?.name === 'rgba' ? undefined : pipeline?.name;
+  const pipelineName = output.name === 'rgba' ? undefined : output.name;
 
   if (pipelineName != null) {
     const sourceId = `${styleId}-${pipelineName}`;
@@ -289,9 +298,51 @@ export interface StyleGet {
   };
 }
 
+/**
+ * Join styles together
+ *
+ * Returns a new style json with sources and layers merged together
+ *
+ * @throws if there are any duplicate layerIds between the styles
+ * @param styles styles to merge together, the first style in the array will be used as the base style and urls will be merged into this style
+ * @returns
+ */
+function mergeStyles(styles: StyleJson[]): StyleJson {
+  const target = structuredClone(styles[0]);
+  if (styles.length === 1) return target;
+
+  const layerId = new Map<string, string>();
+  for (const l of target.layers) layerId.set(l.id, target.id);
+
+  for (const st of styles.slice(1)) {
+    for (const newLayers of st.layers) {
+      if (layerId.has(newLayers.id)) {
+        const prev = layerId.get(newLayers.id);
+        throw new LambdaHttpResponse(
+          400,
+          `Cannot merge styles with duplicate layerIds! styles: "${prev}" "${st.id}" layer: ${newLayers.id}`,
+        );
+      }
+      layerId.set(newLayers.id, st.id);
+    }
+
+    if (target.glyphs == null) target.glyphs = st.glyphs;
+    if (target.sprite == null) target.sprite = st.sprite;
+    if (target.sky == null) target.sky = st.sky;
+
+    Object.assign(target.sources, st.sources);
+    target.layers.push(...st.layers);
+    target.name = target.name + '_' + st.name;
+    target.id = target.id + '_' + st.id;
+  }
+
+  return target;
+}
+
 export async function styleJsonGet(req: LambdaHttpRequest<StyleGet>): Promise<LambdaHttpResponse> {
   const apiKey = Validate.apiKey(req);
-  const styleName = req.params.styleName;
+  const styleNames = req.params.styleName.split(',').filter((f) => f.trim().length > 0);
+  if (styleNames.length > 9) throw new LambdaHttpResponse(400, 'Too many styles requested, max 10');
 
   const tileMatrix = TileMatrixSets.find(req.query.get('tileMatrix') ?? GoogleTms.identifier);
   if (tileMatrix == null) return new LambdaHttpResponse(400, 'Invalid tile matrix');
@@ -302,23 +353,32 @@ export async function styleJsonGet(req: LambdaHttpRequest<StyleGet>): Promise<La
   if (excluded.size > 0) req.set('excludedLayers', [...excluded]);
 
   /**
-   * Configuration options used for the landing page:
-   * "terrain" - force add a terrain layer
-   * "labels" - merge the labels style with the current style
+   * Force add a terrain layer
    *
-   * TODO: (2024-08) this is not a very scalable way of configuring styles, it would be good to provide a styleJSON merge
+   * @deprecated 2026-02: use "/aerial,terrain-v2.json"
    */
   const terrain = req.query.get('terrain') ?? undefined;
+  /**
+   * Merge the labels style with the current style
+   *
+   * @deprecated 2026-02: use "/aerial,labels-v2.json"
+   */
   const labels = Boolean(req.query.get('labels') ?? false);
-  req.set('styleConfig', { terrain, labels });
+  req.set('styleConfig', { terrain, labels, styles: styleNames });
 
   // Get style Config from db
   const config = await ConfigLoader.load(req);
-  const styleConfig = await config.Style.get(styleName);
-  const styleSource =
-    styleConfig?.style ?? (await generateStyleFromTileSet(req, config, styleName, tileMatrix, apiKey));
 
-  const targetStyle = structuredClone(styleSource);
+  const styles = await Promise.all(
+    styleNames.map(async (styleName) => {
+      const styleConfig = await config.Style.get(styleName);
+      if (styleConfig?.style != null) return styleConfig.style;
+      return generateStyleFromTileSet(req, config, styleName, tileMatrix, apiKey);
+    }),
+  );
+
+  const targetStyle = mergeStyles(styles);
+
   // 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, targetStyle);

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

@@ -1,14 +1,14 @@
 import { ConfigTileSetRaster, getAllImagery } from '@basemaps/config';
 import { Bounds, Epsg, TileMatrixSet, TileMatrixSets } from '@basemaps/geo';
 import { Cotar, Env, stringToUrlFolder, Tiff } from '@basemaps/shared';
-import { getImageFormat, Tiler } from '@basemaps/tiler';
+import { Tiler } from '@basemaps/tiler';
 import { TileMakerSharp } from '@basemaps/tiler-sharp';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import pLimit from 'p-limit';
 
 import { ConfigLoader } from '../util/config.loader.js';
 import { Etag } from '../util/etag.js';
-import { NotFound, NotModified } from '../util/response.js';
+import { NotModified } from '../util/response.js';
 import { CoSources } from '../util/source.cache.js';
 import { TileXyz, Validate } from '../util/validate.js';
 
@@ -118,9 +118,8 @@ export const TileXyzRaster = {
   },
 
   async tile(req: LambdaHttpRequest, tileSet: ConfigTileSetRaster, xyz: TileXyz): Promise<LambdaHttpResponse> {
-    const tileOutput = Validate.pipeline(tileSet, xyz.tileType, xyz.pipeline);
-    if (tileOutput == null) return NotFound();
-    req.set('pipeline', tileOutput.name);
+    const { output, format } = Validate.pipeline(tileSet, xyz.tileType, xyz.pipeline);
+    req.set('pipeline', output.name);
 
     const assetPaths = await this.getAssetsForTile(req, tileSet, xyz);
     const cacheKey = Etag.key(assetPaths);
@@ -131,15 +130,12 @@ export const TileXyzRaster = {
     const tiler = new Tiler(xyz.tileMatrix);
     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);
-
     const res = await TileComposer.compose({
       layers,
-      pipeline: tileOutput.pipeline,
+      pipeline: output.pipeline,
       format,
-      background: tileOutput.background ?? tileSet.background ?? DefaultBackground,
-      resizeKernel: tileOutput.resizeKernel ?? tileSet.resizeKernel ?? DefaultResizeKernel,
+      background: output.background ?? tileSet.background ?? DefaultBackground,
+      resizeKernel: output.resizeKernel ?? tileSet.resizeKernel ?? DefaultResizeKernel,
       metrics: req.timer,
       log: req.log,
     });

package/src/util/validate.ts

@@ -16,7 +16,7 @@ export interface TileXyz {
   /** Output tile format */
   tileType: string;
   /** Optional processing pipeline to use */
-  pipeline?: string | null;
+  pipeline?: string;
 }
 
 export interface TileMatrixRequest {
@@ -118,15 +118,15 @@ export const Validate = {
     if (isNaN(x) || x < 0 || x > zoom.matrixWidth) throw new LambdaHttpResponse(404, `X not found: ${x}`);
     if (isNaN(y) || y < 0 || y > zoom.matrixHeight) throw new LambdaHttpResponse(404, `Y not found: ${y}`);
 
-    const pipeline = req.query.get('pipeline');
-    if (pipeline) req.set('pipeline', pipeline);
+    const pipeline = req.query.get('pipeline') ?? undefined;
+    req.set('pipeline', pipeline);
 
     const xyzData = {
       tile: { x, y, z },
       tileSet: req.params.tileSet,
       tileMatrix,
       tileType: req.params.tileType,
-      pipeline: req.query.get('pipeline'),
+      pipeline,
     };
     req.set('xyz', xyzData.tile);
 
@@ -137,42 +137,68 @@ export const Validate = {
   },
 
   /**
-   * Lookup the raster configuration pipeline for a output tile type
+   * Get the pipeline to use for a imagery set
    *
-   * Defaults to standard image format output if no outputs are defined on the tileset
+   * @param tileSet
+   * @param pipeline pipeline parameter if it exists
+   * @returns 'rgba' for any pipeline without outputs, otherwise the provided pipeline or default output
    */
-  pipeline(tileSet: ConfigTileSetRaster, tileType: string, pipeline?: string | null): ConfigTileSetRasterOutput | null {
-    // If there is only one pipeline force the use of it
-    if (tileSet.outputs?.length === 1 && pipeline == null) pipeline = tileSet.outputs[0].name;
-
-    if (pipeline != null && pipeline !== 'rgba') {
-      if (tileSet.outputs == null) throw new LambdaHttpResponse(404, 'TileSet has no pipelines');
-      const output = tileSet.outputs.find((f) => f.name === pipeline);
-      if (output == null) throw new LambdaHttpResponse(404, `TileSet has no pipeline named "${pipeline}"`);
-
-      const validFormats = output.format ?? ['webp', 'png', 'jpeg', 'avif'];
-      if (!validFormats.includes(tileType as ImageFormat)) {
-        throw new LambdaHttpResponse(400, `TileSet pipeline "${pipeline}" cannot be output as ${tileType}`);
-      }
-      return output;
-    }
+  pipelineName(tileSet: ConfigTileSetRaster, pipeline?: string | null): ConfigTileSetRasterOutput {
+    if (pipeline == null && tileSet.outputs) {
+      // If no pipeline is specified find the default pipeline
+      const defaultOutput = tileSet.outputs.find((f) => f.default === true);
+      if (defaultOutput) return defaultOutput;
 
-    // If the tileset has multiple pipelines defined the user MUST specify which one
-    if (tileSet.outputs) {
+      // If there is only one pipeline force the use of it
+      if (tileSet.outputs.length === 1) return tileSet.outputs[0];
+
+      // No default pipeline, and multiple pipelines exist one must be chosen
       throw new LambdaHttpResponse(404, 'TileSet needs pipeline: ' + tileSet.outputs.map((f) => f.name).join(', '));
     }
 
-    // Generate a default RGBA configuration
-    const img = getImageFormat(tileType ?? 'webp');
-    if (img == null) return null;
-    return {
-      title: `RGBA ${tileType}`,
-      name: 'rgba',
-      output: {
-        type: [img],
-        lossless: img === 'png' ? true : false,
+    // No pipeline and no outputs default is RGBA
+    if (pipeline == null || pipeline === 'rgba') {
+      return {
+        title: `RGBA`,
+        name: 'rgba',
         background: tileSet.background,
-      },
-    } as ConfigTileSetRasterOutput;
+      };
+    }
+
+    // Pipeline defined and pipeline not found
+    if (tileSet.outputs == null) throw new LambdaHttpResponse(404, `TileSet has no pipeline named "${pipeline}"`);
+
+    const output = tileSet.outputs.find((f) => f.name === pipeline);
+    if (output == null) throw new LambdaHttpResponse(404, `TileSet has no pipeline named "${pipeline}"`);
+    return output;
+  },
+
+  /**
+   * Lookup the raster configuration pipeline for a output tile type
+   *
+   * Defaults to standard image format output if no outputs are defined on the tileset
+   */
+  pipeline(
+    tileSet: ConfigTileSetRaster,
+    imageFormat?: string | null,
+    pipelineName?: string | null,
+  ): { output: ConfigTileSetRasterOutput; format: ImageFormat } {
+    const output = Validate.pipelineName(tileSet, pipelineName);
+
+    // Failed to parse the chosen image format
+    const chosenFormat = getImageFormat(imageFormat);
+    if (imageFormat != null && chosenFormat == null) {
+      throw new LambdaHttpResponse(400, `TileSet pipeline "${output.name}" cannot be output as ${imageFormat}`);
+    }
+
+    // No requirement on image formats
+    if (output.format == null) return { output, format: chosenFormat ?? 'webp' };
+    if (chosenFormat == null) return { output, format: output.format[0] };
+
+    // Validate selected format works as expected
+    if (!output.format.includes(chosenFormat)) {
+      throw new LambdaHttpResponse(400, `TileSet pipeline "${output.name}" cannot be output as ${imageFormat}`);
+    }
+    return { output, format: chosenFormat };
   },
 };