@basemaps/lambda-tiler 7.9.0 → 7.10.0

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}`);
     }
   }
 

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

@@ -1,20 +1,41 @@
-import { ConfigId, ConfigPrefix, ConfigTileSetRaster, Layer, Sources, StyleJson, TileSetType } from '@basemaps/config';
+import {
+  BasemapsConfigProvider,
+  ConfigId,
+  ConfigPrefix,
+  ConfigTileSetRaster,
+  Layer,
+  Sources,
+  StyleJson,
+  TileSetType,
+} from '@basemaps/config';
 import { DefaultExaggeration } from '@basemaps/config/build/config/vector.style.js';
-import { GoogleTms, TileMatrixSet, TileMatrixSets } from '@basemaps/geo';
+import { GoogleTms, Nztm2000QuadTms, TileMatrixSet, TileMatrixSets } from '@basemaps/geo';
 import { Env, toQueryString } from '@basemaps/shared';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import { URL } from 'url';
 
 import { ConfigLoader } from '../util/config.loader.js';
 import { Etag } from '../util/etag.js';
+import { convertStyleToNztmStyle } from '../util/nztm.style.js';
 import { NotFound, NotModified } from '../util/response.js';
 import { Validate } from '../util/validate.js';
 
 /**
- * Convert relative URLS into a full hostname url
+ * Convert relative URL into a full hostname URL, converting {tileMatrix} into the provided tileMatrix
+ *
+ * Will also add query parameters of apiKey and configuration if provided
+ *
+ * @example
+ * ```typescript
+ * convertRelativeUrl("/v1/tiles/aerial/{tileMatrix}/{z}/{x}/{y}.webp", NZTM2000Quad)
+ * "https://basemaps.linz.govt.nz/v1/tiles/aerial/NZTM2000Quad/{z}/{x}/{y}.webp?api=c..."
+ * ```
+ *
  * @param url possible url to update
  * @param apiKey ApiKey to append with ?api= if required
- * @returns Updated Url or empty string if url is empty
+ * @param tileMatrix replace {tileMatrix} with the tile matrix
+ *
+ * @returns Updated URL or empty string if url is empty
  */
 export function convertRelativeUrl(
   url?: string,
@@ -33,20 +54,17 @@ export function convertRelativeUrl(
 }
 
 /**
- * Create a new style json that has absolute urls to the current host and  API Keys where required
+ * Update the style JSON to have absolute urls to the current host and API Keys where required
+ *
  * @param style style to update
+ * @param tileMatrix convert the tile matrix to the target tile matrix
  * @param apiKey api key to inject
- * @returns new stylejson
+ * @param config optional configuration url to use
+ * @param layers replace the layers in the style json
+ * @returns new style JSON
  */
-export function convertStyleJson(
-  style: StyleJson,
-  tileMatrix: TileMatrixSet,
-  apiKey: string,
-  config: string | null,
-  layers?: Layer[],
-): StyleJson {
-  const sources = JSON.parse(JSON.stringify(style.sources)) as Sources;
-  for (const [key, value] of Object.entries(sources)) {
+export function setStyleUrls(style: StyleJson, tileMatrix: TileMatrixSet, apiKey: string, config: string | null): void {
+  for (const [key, value] of Object.entries(style.sources ?? {})) {
     if (value.type === 'vector') {
       value.url = convertRelativeUrl(value.url, tileMatrix, apiKey, config);
     } else if ((value.type === 'raster' || value.type === 'raster-dem') && Array.isArray(value.tiles)) {
@@ -54,30 +72,11 @@ export function convertStyleJson(
         value.tiles[i] = convertRelativeUrl(value.tiles[i], tileMatrix, apiKey, config);
       }
     }
-    sources[key] = value;
+    style.sources[key] = value;
   }
 
-  const styleJson: StyleJson = {
-    version: 8,
-    id: style.id,
-    name: style.name,
-    sources,
-    layers: layers ? layers : style.layers,
-  };
-
-  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;
-  if (style.terrain) styleJson.terrain = style.terrain;
-
-  return styleJson;
-}
-
-export interface StyleGet {
-  Params: {
-    styleName: string;
-  };
+  if (style.glyphs) style.glyphs = convertRelativeUrl(style.glyphs, undefined, undefined, config);
+  if (style.sprite) style.sprite = convertRelativeUrl(style.sprite, undefined, undefined, config);
 }
 
 export interface StyleConfig {
@@ -87,15 +86,21 @@ export interface StyleConfig {
   labels: boolean;
 }
 
+/**
+ * Turn on the terrain setting in the style json
+ */
 function setStyleTerrain(style: StyleJson, terrain: string, tileMatrix: TileMatrixSet): 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.`);
+  if (source == null) throw new LambdaHttpResponse(400, `Terrain: ${terrain} does not exists in the style source.`);
   style.terrain = {
     source,
     exaggeration: DefaultExaggeration[tileMatrix.identifier] ?? DefaultExaggeration[GoogleTms.identifier],
   };
 }
 
+/**
+ * Merge the "labels" layer into the style json
+ */
 async function setStyleLabels(req: LambdaHttpRequest<StyleGet>, style: StyleJson): Promise<void> {
   const config = await ConfigLoader.load(req);
   const labels = await config.Style.get('labels');
@@ -122,6 +127,9 @@ async function setStyleLabels(req: LambdaHttpRequest<StyleGet>, style: StyleJson
   style.layers = style.layers.concat(labels.style.layers);
 }
 
+/**
+ * Ensure that a "LINZ-Terrain" layer is force added into the output styleJSON source
+ */
 async function ensureTerrain(
   req: LambdaHttpRequest<StyleGet>,
   tileMatrix: TileMatrixSet,
@@ -136,20 +144,26 @@ async function ensureTerrain(
   style.sources['LINZ-Terrain'] = {
     type: 'raster-dem',
     tileSize: 256,
-    maxzoom: 18,
+    maxzoom: 18, // TODO: this should be configurable based on the elevation layer
     tiles: [convertRelativeUrl(`/v1/tiles/elevation/${tileMatrix.identifier}/{z}/{x}/{y}.png${elevationQuery}`)],
   };
 }
 
-export async function tileSetToStyle(
+/**
+ * Generate a StyleJSON from a tileset
+ * @returns
+ */
+export function tileSetToStyle(
   req: LambdaHttpRequest<StyleGet>,
   tileSet: ConfigTileSetRaster,
   tileMatrix: TileMatrixSet,
   apiKey: string,
-  cfg: StyleConfig,
-): Promise<LambdaHttpResponse> {
+): StyleJson {
+  // 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) return new LambdaHttpResponse(400, 'Invalid image format');
+  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;
@@ -162,162 +176,134 @@ export async function tileSetToStyle(
     `/v1/tiles/${tileSet.name}/${tileMatrix.identifier}/{z}/{x}/{y}.${tileFormat}${query}`;
 
   const styleId = `basemaps-${tileSet.name}`;
-  const style: StyleJson = {
+  return {
     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 (cfg.terrain) setStyleTerrain(style, cfg.terrain, tileMatrix);
-  if (cfg.labels) await setStyleLabels(req, style);
-
-  const data = Buffer.from(JSON.stringify(convertStyleJson(style, tileMatrix, apiKey, configLocation)));
-
-  const cacheKey = Etag.key(data);
-  if (Etag.isNotModified(req, cacheKey)) return 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;
 }
 
-export async function tileSetOutputToStyle(
+/**
+ * generate a style from a tile set which has a output
+ */
+export function tileSetOutputToStyle(
   req: LambdaHttpRequest<StyleGet>,
   tileSet: ConfigTileSetRaster,
   tileMatrix: TileMatrixSet,
   apiKey: string,
-  cfg: StyleConfig,
-): Promise<LambdaHttpResponse> {
+): StyleJson {
+  if (tileSet.outputs == null) throw new LambdaHttpResponse(400, 'TileSet does not have any outputs to generate');
   const configLocation = ConfigLoader.extract(req);
-  const query = toQueryString({ config: configLocation, api: apiKey });
 
   const styleId = `basemaps-${tileSet.name}`;
   const sources: Sources = {};
   const layers: Layer[] = [];
 
-  if (tileSet.outputs) {
-    //for loop output.
-    for (const output of tileSet.outputs) {
-      const format = output.format?.[0] ?? 'webp';
-      const urlBase = Env.get(Env.PublicUrlBase) ?? '';
-      const tileUrl = `${urlBase}/v1/tiles/${tileSet.name}/${tileMatrix.identifier}/{z}/{x}/{y}.${format}${query}`;
-
-      if (output.name === 'terrain-rgb') {
-        // Add both raster source and dem raster source for terrain-rgb output
-        sources[`${styleId}-${output.name}`] = {
-          type: 'raster',
-          tiles: [tileUrl + `&pipeline=${output.name}`],
-          tileSize: 256,
-        };
-        sources[`${styleId}-${output.name}-dem`] = {
-          type: 'raster-dem',
-          tiles: [tileUrl + `&pipeline=${output.name}`],
-          tileSize: 256,
-        };
-      } else {
-        // Add raster source other outputs
-        sources[`${styleId}-${output.name}`] = {
-          type: 'raster',
-          tiles: [tileUrl + `&pipeline=${output.name}`],
-          tileSize: 256,
-        };
-      }
+  for (const output of tileSet.outputs) {
+    const format = output.format?.[0] ?? 'webp';
+    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}`;
+
+    if (output.name === 'terrain-rgb') {
+      // Add both raster source and dem raster source for terrain-rgb output
+      sources[`${styleId}-${output.name}`] = { type: 'raster', tiles: [tileUrl], tileSize: 256 };
+      sources[`${styleId}-${output.name}-dem`] = { type: 'raster-dem', tiles: [tileUrl], tileSize: 256 };
+    } else {
+      // Add raster source other outputs
+      sources[`${styleId}-${output.name}`] = { type: 'raster', tiles: [tileUrl], tileSize: 256 };
     }
   }
 
   // Add first raster source as default layer
   for (const source of Object.keys(sources)) {
     if (sources[source].type === 'raster') {
-      layers.push({
-        id: styleId,
-        type: 'raster',
-        source,
-      });
+      layers.push({ id: styleId, type: 'raster', source });
       break;
     }
   }
 
-  const style: StyleJson = {
+  return {
     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 (cfg.terrain) setStyleTerrain(style, cfg.terrain, tileMatrix);
-  if (cfg.labels) await setStyleLabels(req, style);
-
-  const data = Buffer.from(JSON.stringify(convertStyleJson(style, tileMatrix, apiKey, configLocation)));
-
-  const cacheKey = Etag.key(data);
-  if (Etag.isNotModified(req, cacheKey)) return Promise.resolve(NotModified());
+async function generateStyleFromTileSet(
+  req: LambdaHttpRequest<StyleGet>,
+  config: BasemapsConfigProvider,
+  tileSetName: string,
+  tileMatrix: TileMatrixSet,
+  apiKey: string,
+): Promise<StyleJson> {
+  const tileSet = await config.TileSet.get(tileSetName);
+  if (tileSet == null) throw NotFound();
+  if (tileSet.type !== TileSetType.Raster) {
+    throw new LambdaHttpResponse(400, 'Only raster tile sets can generate style JSON');
+  }
+  if (tileSet.outputs) return tileSetOutputToStyle(req, tileSet, tileMatrix, apiKey);
+  else return tileSetToStyle(req, tileSet, tileMatrix, apiKey);
+}
 
-  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 Promise.resolve(response);
+export interface StyleGet {
+  Params: {
+    styleName: string;
+  };
 }
 
 export async function styleJsonGet(req: LambdaHttpRequest<StyleGet>): Promise<LambdaHttpResponse> {
   const apiKey = Validate.apiKey(req);
   const styleName = req.params.styleName;
-  const excludeLayers = req.query.getAll('exclude');
-  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');
+
+  // Remove layers from the output style json
+  const excludeLayers = req.query.getAll('exclude');
+  const excluded = new Set(excludeLayers.map((l) => l.toLowerCase()));
+  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
+   *
+   * TODO: (2024-08) this is not a very scalable way of configuring styles, it would be good to provide a styleJSON merge
+   */
   const terrain = req.query.get('terrain') ?? undefined;
   const labels = Boolean(req.query.get('labels') ?? false);
+  req.set('styleConfig', { terrain, labels });
 
   // Get style Config from db
   const config = await ConfigLoader.load(req);
-  const dbId = config.Style.id(styleName);
-  const styleConfig = await config.Style.get(dbId);
-
-  req.set('styleConfig', { terrain, labels });
-
-  if (styleConfig == null) {
-    // Were we given a tileset name instead, generated
-    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 await tileSetOutputToStyle(req, tileSet, tileMatrix, apiKey, { terrain, labels });
-    else return await tileSetToStyle(req, tileSet, tileMatrix, apiKey, { terrain, labels });
-  }
-
-  // Prepare sources and add linz source
-  const style = convertStyleJson(
-    styleConfig.style,
-    tileMatrix,
-    apiKey,
-    ConfigLoader.extract(req),
-    styleConfig.style.layers.filter((f) => !excluded.has(f.id.toLowerCase())),
-  );
+  const styleConfig = await config.Style.get(styleName);
+  const styleSource =
+    styleConfig?.style ?? (await generateStyleFromTileSet(req, config, styleName, tileMatrix, apiKey));
 
+  const targetStyle = structuredClone(styleSource);
   // 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);
+  await ensureTerrain(req, tileMatrix, apiKey, targetStyle);
 
   // Add terrain in style
-  if (terrain) setStyleTerrain(style, terrain, tileMatrix);
-  if (labels) await setStyleLabels(req, style);
+  if (terrain) setStyleTerrain(targetStyle, terrain, tileMatrix);
+  if (labels) await setStyleLabels(req, targetStyle);
+
+  // convert sources to full URLS and convert style between projections
+  setStyleUrls(targetStyle, tileMatrix, apiKey, ConfigLoader.extract(req));
+
+  if (tileMatrix.identifier === Nztm2000QuadTms.identifier) convertStyleToNztmStyle(targetStyle, false);
+
+  // filter out any excluded layers
+  if (excluded.size > 0) targetStyle.layers = targetStyle.layers.filter((f) => !excluded.has(f.id.toLowerCase()));
 
-  const data = Buffer.from(JSON.stringify(style));
+  const data = Buffer.from(JSON.stringify(targetStyle));
 
   const cacheKey = Etag.key(data);
   if (Etag.isNotModified(req, cacheKey)) return NotModified();

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

@@ -1,5 +1,4 @@
 import { ConfigTileSetVector } from '@basemaps/config';
-import { GoogleTms } from '@basemaps/geo';
 import { fsa } from '@basemaps/shared';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 
@@ -13,12 +12,17 @@ export const tileXyzVector = {
   /** Serve a MVT vector tile */
   async tile(req: LambdaHttpRequest, tileSet: ConfigTileSetVector, xyz: TileXyz): Promise<LambdaHttpResponse> {
     if (xyz.tileType !== 'pbf') return NotFound();
-    if (xyz.tileMatrix.identifier !== GoogleTms.identifier) return NotFound();
 
-    if (tileSet.layers.length > 1) return new LambdaHttpResponse(500, 'Too many layers in tileset');
-    const [layer] = tileSet.layers;
-    const layerId = layer[3857];
-    if (layerId == null) return new LambdaHttpResponse(500, 'Layer url not found from tileset Config');
+    // Vector tiles cannot be merged (yet!)
+    if (tileSet.layers.length > 1) {
+      return new LambdaHttpResponse(500, `Too many layers in vector tileset ${tileSet.layers.length}`);
+    }
+
+    const epsgCode = xyz.tileMatrix.projection.code;
+    const layerId = tileSet.layers[0][epsgCode];
+    if (layerId == null) {
+      return new LambdaHttpResponse(404, `No data found for tile matrix: ${xyz.tileMatrix.identifier}`);
+    }
 
     // Flip Y coordinate because MBTiles files are TMS.
     const y = (1 << xyz.tile.z) - 1 - xyz.tile.y;