@basemaps/lambda-tiler 8.11.0 → 8.12.2

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 };
   },
 };

package/src/wmts.capability.ts

@@ -1,4 +1,11 @@
-import { ConfigImagery, ConfigLayer, ConfigTileSet, standardizeLayerName } from '@basemaps/config';
+import {
+  ConfigImagery,
+  ConfigLayer,
+  ConfigTileSet,
+  ConfigTileSetRasterOutput,
+  standardizeLayerName,
+  TileSetType,
+} from '@basemaps/config';
 import { BoundingBox, Bounds, GoogleTms, ImageFormat, Projection, TileMatrixSet, WmtsProvider } from '@basemaps/geo';
 import { toQueryString, V, VNodeElement } from '@basemaps/shared';
 import { ImageFormatOrder } from '@basemaps/tiler';
@@ -74,7 +81,13 @@ export class WmtsBuilder {
     for (const format of formats) this.formats.push(format);
   }
 
-  getFormats(): ImageFormat[] {
+  getFormats(restrictTo?: ImageFormat[]): ImageFormat[] {
+    if (restrictTo) {
+      if (this.formats.length === 0) return restrictTo;
+      const filtered = this.formats.filter((f) => restrictTo.includes(f));
+      if (filtered.length === 0) return restrictTo;
+      return filtered;
+    }
     if (this.formats.length) return this.formats;
     return ImageFormatOrder;
   }
@@ -154,17 +167,17 @@ export class WmtsBuilder {
     return V('Style', { isDefault: 'true' }, [V('ows:Title', 'Default Style'), V('ows:Identifier', 'default')]);
   }
 
-  buildResourceUrl(tileSetId: string, suffix: string): VNodeElement {
+  buildResourceUrl(tileSetId: string, suffix: string, pipeline?: string): VNodeElement {
     return V('ResourceURL', {
       format: 'image/' + suffix,
       resourceType: 'tile',
-      template: this.buildTileUrl(tileSetId, suffix),
+      template: this.buildTileUrl(tileSetId, suffix, pipeline),
     });
   }
 
-  buildTileUrl(tileSetId: string, suffix: string): string {
+  buildTileUrl(tileSetId: string, suffix: string, pipeline?: string): string {
     // TODO this should restrict the output formats to supported formats in pipelines
-    const query = { api: this.apiKey, config: this.config, pipeline: this.pipeline };
+    const query = { api: this.apiKey, config: this.config, pipeline };
 
     return [
       this.httpBase,
@@ -178,10 +191,6 @@ export class WmtsBuilder {
     ].join('/');
   }
 
-  buildFormats(): VNodeElement[] {
-    return this.getFormats().map((fmt) => V('Format', 'image/' + fmt));
-  }
-
   buildTileMatrixLink(tileSet: ConfigTileSet): VNodeElement[] {
     const matrixSetNodes: VNodeElement[] = [];
     for (const tms of this.tileMatrixSets.values()) {
@@ -319,7 +328,7 @@ export class WmtsCapabilities extends WmtsBuilder {
     ];
   }
 
-  toLayerVNode(tileSet: ConfigTileSet): VNodeElement {
+  toLayerVNode(tileSet: ConfigTileSet): VNodeElement[] {
     const matrixSets = this.getMatrixSets(tileSet);
     const matrixSetList = [...matrixSets.values()];
     const firstMatrix = matrixSetList[0];
@@ -334,19 +343,43 @@ export class WmtsCapabilities extends WmtsBuilder {
       bounds.push(Bounds.fromJson(img.bounds));
     }
 
+    const layers: VNodeElement[] = [];
+
+    const pipelines = this.getPipelines(tileSet, this.pipeline);
+
     const layerNameId = standardizeLayerName(tileSet.name);
-    return V('Layer', [
-      V('ows:Title', tileSet.title),
-      V('ows:Abstract', tileSet.description ?? ''),
-      V('ows:Identifier', layerNameId),
-      this.buildKeywords(tileSet),
-      ...[...matrixSets.values()].map((tms) => this.buildBoundingBoxFromImagery(tms, tileSet.layers)),
-      this.buildWgs84BoundingBox(webMercatorOrFirst, bounds),
-      this.buildStyle(),
-      ...this.buildFormats(),
-      ...this.buildTileMatrixLink(tileSet),
-      ...this.getFormats().map((fmt) => this.buildResourceUrl(layerNameId, fmt)),
-    ]);
+
+    for (const pipeline of pipelines) {
+      const formats = this.getFormats(pipeline.format);
+      const layerId = pipeline.default ? layerNameId : `${layerNameId}_${pipeline.name}`;
+      const layerTitle = pipeline.default ? tileSet.title : `${tileSet.title} ${pipeline.title}`;
+
+      const layer = V('Layer', [
+        V('ows:Title', layerTitle),
+        V('ows:Abstract', tileSet.description ?? ''),
+        V('ows:Identifier', layerId),
+        this.buildKeywords(tileSet),
+        ...[...matrixSets.values()].map((tms) => this.buildBoundingBoxFromImagery(tms, tileSet.layers)),
+        this.buildWgs84BoundingBox(webMercatorOrFirst, bounds),
+        this.buildStyle(),
+        ...formats.map((fmt) => V('Format', 'image/' + fmt)),
+        ...this.buildTileMatrixLink(tileSet),
+        ...formats.map((fmt) => this.buildResourceUrl(layerNameId, fmt, pipeline.default ? undefined : pipeline.name)),
+      ]);
+      layers.push(layer);
+    }
+
+    return layers;
+  }
+
+  getPipelines(tileSet: ConfigTileSet, pipeline?: string): ConfigTileSetRasterOutput[] {
+    if (tileSet.type !== TileSetType.Raster) return [];
+
+    if (tileSet.outputs == null) return [{ name: 'rgba', title: 'RGBA', default: true }];
+
+    if (pipeline) return tileSet.outputs.filter((f) => f.name === pipeline);
+
+    return tileSet.outputs;
   }
 
   toAllImageryLayersVNode(configLayers?: ConfigLayer[]): VNodeElement[] {
@@ -393,7 +426,7 @@ export class WmtsCapabilities extends WmtsBuilder {
 
     // Build TileSet Layer VNodes
     const layers: VNodeElement[] = [];
-    layers.push(this.toLayerVNode(this.tileSet));
+    layers.push(...this.toLayerVNode(this.tileSet));
     const contents = layers.concat(this.toAllImageryLayersVNode(this.configLayers));
 
     // Build TileMatrix Sets vNodes