@basemaps/lambda-tiler 6.29.0 → 6.32.0

package/src/routes/attribution.ts

@@ -1,4 +1,4 @@
-import { ConfigImagery, ConfigLayer, ConfigProvider, TileSetType } from '@basemaps/config';
+import { ConfigTileSet, TileSetType } from '@basemaps/config';
 import {
   AttributionCollection,
   AttributionItem,
@@ -7,32 +7,20 @@ import {
   GoogleTms,
   NamedBounds,
   Stac,
-  StacCollection,
   StacExtent,
   TileMatrixSet,
 } from '@basemaps/geo';
-import {
-  CompositeError,
-  Config,
-  extractYearRangeFromName,
-  fsa,
-  Projection,
-  setNameAndProjection,
-  tileAttributionFromPath,
-  titleizeImageryName,
-} from '@basemaps/shared';
+import { Config, extractYearRangeFromName, Projection, titleizeImageryName } from '@basemaps/shared';
 import { BBox, MultiPolygon, multiPolygonToWgs84, Pair, union, Wgs84 } from '@linzjs/geojson';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
-import { createHash } from 'crypto';
-import { Router } from '../router.js';
-import { TileSets } from '../tile.set.cache.js';
-import { TileSetRaster } from '../tile.set.raster.js';
+
+import { Etag } from '../util/etag.js';
+import { NotFound, NotModified } from '../util/response.js';
+import { Validate } from '../util/validate.js';
 
 /** Amount to pad imagery bounds to avoid fragmenting polygons  */
 const SmoothPadding = 1 + 1e-10; // about 1/100th of a millimeter at equator
 
-const NotFound = new LambdaHttpResponse(404, 'Not Found');
-
 const Precision = 10 ** 8;
 
 /**
@@ -74,90 +62,38 @@ function createCoordinates(bbox: BBox, files: NamedBounds[], proj: Projection):
   return multiPolygonToWgs84(coordinates, roundToWgs84);
 }
 
-async function readStac(uri: string): Promise<StacCollection | null> {
-  try {
-    return await fsa.readJson<StacCollection>(uri);
-  } catch (err) {
-    if (CompositeError.isCompositeError(err) && err.code < 500) {
-      return null;
-    }
-    throw err;
-  }
-}
-
-export function createAttributionCollection(
-  tileSet: TileSetRaster,
-  stac: StacCollection | null | undefined,
-  imagery: ConfigImagery,
-  layer: ConfigLayer,
-  host: ConfigProvider,
-  extent: StacExtent,
-): AttributionCollection {
-  const tileMatrix = tileSet.tileMatrix;
-  return {
-    stac_version: Stac.Version,
-    license: stac?.license ?? Stac.License,
-    id: imagery.id,
-    providers: stac?.providers ?? [
-      { name: host.serviceProvider.name, url: host.serviceProvider.site, roles: ['host'] },
-    ],
-    title: stac?.title ?? titleizeImageryName(imagery.name),
-    description: stac?.description ?? 'No description',
-    extent,
-    links: [],
-    summaries: {
-      'linz:zoom': {
-        min: TileMatrixSet.convertZoomLevel(layer.minZoom ? layer.minZoom : 0, GoogleTms, tileMatrix, true),
-        max: TileMatrixSet.convertZoomLevel(layer.maxZoom ? layer.maxZoom : 32, GoogleTms, tileMatrix, true),
-      },
-      'linz:priority': [1000 + tileSet.tileSet.layers.indexOf(layer)],
-    },
-  };
-}
-
 /**
  * Build a Single File STAC for the given TileSet.
  *
  * For now this is the minimal set required for attribution. This can be embellished later with
  * links and assets for a more comprehensive STAC file.
  */
-async function tileSetAttribution(tileSet: TileSetRaster): Promise<AttributionStac | null> {
-  const proj = Projection.get(tileSet.tileMatrix);
-  const stacFiles = new Map<string, Promise<StacCollection | null>>();
+async function tileSetAttribution(
+  req: LambdaHttpRequest,
+  tileSet: ConfigTileSet,
+  tileMatrix: TileMatrixSet,
+): Promise<AttributionStac | null> {
+  const proj = Projection.get(tileMatrix);
   const cols: AttributionCollection[] = [];
   const items: AttributionItem[] = [];
 
-  // read all stac files in parallel
-  for (const layer of tileSet.tileSet.layers) {
-    const imgId = layer[proj.epsg.code];
-    if (imgId == null) continue;
-    const im = tileSet.imagery.get(imgId);
-    if (im == null) continue;
-    if (stacFiles.get(im.uri) == null) {
-      stacFiles.set(im.uri, readStac(fsa.join(im.uri, 'collection.json')));
-    }
-  }
+  const imagery = await Config.getAllImagery(tileSet.layers, [tileMatrix.projection]);
 
   const host = await Config.Provider.get(Config.Provider.id('linz'));
   if (host == null) return null;
 
-  for (const layer of tileSet.tileSet.layers) {
+  for (const layer of tileSet.layers) {
     const imgId = layer[proj.epsg.code];
     if (imgId == null) continue;
-    const im = tileSet.imagery.get(imgId);
+    const im = imagery.get(imgId);
     if (im == null) continue;
-    const stac = await stacFiles.get(im.uri);
 
     const bbox = proj.boundsToWgs84BoundingBox(im.bounds).map(roundNumber) as BBox;
 
-    let interval: [string, string][] | undefined = stac?.extent.temporal.interval;
-    if (interval == null) {
-      const years = extractYearRangeFromName(im.name);
-      if (years[0] === -1) {
-        throw new Error('Missing date in imagery name: ' + im.name);
-      }
-      interval = [years.map((y) => `${y}-01-01T00:00:00Z`) as [string, string]];
-    }
+    const years = extractYearRangeFromName(im.name);
+    if (years[0] === -1) throw new Error('Missing date in imagery name: ' + im.name);
+    const interval = [years.map((y) => `${y}-01-01T00:00:00Z`) as [string, string]];
+
     const extent: StacExtent = { spatial: { bbox: [bbox] }, temporal: { interval } };
 
     items.push({
@@ -168,68 +104,80 @@ async function tileSetAttribution(tileSet: TileSetRaster): Promise<AttributionSt
       assets: {},
       links: [],
       bbox,
-      geometry: {
-        type: 'MultiPolygon',
-        coordinates: createCoordinates(bbox, im.files, proj),
-      },
+      geometry: { type: 'MultiPolygon', coordinates: createCoordinates(bbox, im.files, proj) },
       properties: {
-        title: titleizeImageryName(im.name),
+        title: im.title ?? titleizeImageryName(im.name),
+        category: im.category,
         datetime: null,
         start_datetime: interval[0][0],
         end_datetime: interval[0][1],
       },
     });
 
-    cols.push(createAttributionCollection(tileSet, stac, im, layer, host, extent));
+    const zoomMin = TileMatrixSet.convertZoomLevel(layer.minZoom ? layer.minZoom : 0, GoogleTms, tileMatrix, true);
+    const zoomMax = TileMatrixSet.convertZoomLevel(layer.maxZoom ? layer.maxZoom : 32, GoogleTms, tileMatrix, true);
+    cols.push({
+      stac_version: Stac.Version,
+      license: Stac.License,
+      id: im.id,
+      providers: [{ name: host.serviceProvider.name, url: host.serviceProvider.site, roles: ['host'] }],
+      title: im.title ?? titleizeImageryName(im.name),
+      description: 'No description',
+      extent,
+      links: [],
+      summaries: {
+        'linz:category': im.category,
+        'linz:zoom': { min: zoomMin, max: zoomMax },
+        'linz:priority': [1000 + tileSet.layers.indexOf(layer)],
+      },
+    });
   }
   return {
     id: tileSet.id,
     type: 'FeatureCollection',
     stac_version: Stac.Version,
     stac_extensions: ['single-file-stac'],
-    title: tileSet.title,
-    description: tileSet.description,
+    title: tileSet.title ?? 'No title',
+    description: tileSet.description ?? 'No Description',
     features: items,
     collections: cols,
     links: [],
   };
 }
 
+export interface TileAttributionGet {
+  Params: {
+    tileSet: string;
+    tileMatrix: string;
+  };
+}
+
 /**
  * Create a LambdaHttpResponse for a attribution request
  */
-export async function attribution(req: LambdaHttpRequest): Promise<LambdaHttpResponse> {
-  const action = Router.action(req);
-  const data = tileAttributionFromPath(action.rest);
-  if (data == null) return NotFound;
-  setNameAndProjection(req, data);
+export async function tileAttributionGet(req: LambdaHttpRequest<TileAttributionGet>): Promise<LambdaHttpResponse> {
+  const tileMatrix = Validate.getTileMatrixSet(req.params.tileMatrix);
+  if (tileMatrix == null) throw new LambdaHttpResponse(404, 'Tile Matrix not found');
 
   req.timer.start('tileset:load');
-  const tileSet = await TileSets.get(data.name, data.tileMatrix);
+  const tileSet = await Config.TileSet.get(Config.TileSet.id(req.params.tileSet));
   req.timer.end('tileset:load');
-  if (tileSet == null || tileSet.type === TileSetType.Vector) return NotFound;
+  if (tileSet == null || tileSet.type === TileSetType.Vector) return NotFound();
 
-  const cacheKey = createHash('sha256').update(JSON.stringify(tileSet.tileSet)).digest('base64');
-
-  const ifNoneMatch = req.header(HttpHeader.IfNoneMatch);
-  if (ifNoneMatch != null && ifNoneMatch.indexOf(cacheKey) > -1) {
-    req.set('cache', { key: cacheKey, hit: true, match: ifNoneMatch });
-    return new LambdaHttpResponse(304, 'Not modified');
-  }
+  const cacheKey = Etag.key(tileSet);
+  if (Etag.isNotModified(req, cacheKey)) return NotModified();
 
   req.timer.start('stac:load');
-  const attributions = await tileSetAttribution(tileSet);
+  const attributions = await tileSetAttribution(req, tileSet, tileMatrix);
   req.timer.end('stac:load');
 
-  if (attributions == null) return NotFound;
+  if (attributions == null) return NotFound();
 
   const response = new LambdaHttpResponse(200, 'ok');
 
   response.header(HttpHeader.ETag, cacheKey);
-  // Keep fresh for one day; otherwise use cache but refresh cache for next time
-  response.header(HttpHeader.CacheControl, 'public, max-age=86400, stale-while-revalidate=604800');
-
+  // Keep fresh for 7 days; otherwise use cache but refresh cache for next time
+  response.header(HttpHeader.CacheControl, 'public, max-age=604800, stale-while-revalidate=86400');
   response.json(attributions);
-
   return response;
 }

package/src/routes/fonts.ts

@@ -1,8 +1,10 @@
 import { Env } from '@basemaps/shared';
 import { fsa } from '@chunkd/fs';
-import { LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import path from 'path';
-import { NotFound } from './response.js';
+import { isGzip, serveFromCotar } from '../util/cotar.serve.js';
+import { Etag } from '../util/etag.js';
+import { NotFound, NotModified } from '../util/response.js';
 
 interface FontGet {
   Params: { fontStack: string; range: string };
@@ -10,15 +12,27 @@ interface FontGet {
 
 export async function fontGet(req: LambdaHttpRequest<FontGet>): Promise<LambdaHttpResponse> {
   const assetLocation = Env.get(Env.AssetLocation);
-  if (assetLocation == null) return NotFound;
+  if (assetLocation == null) return NotFound();
+
+  const targetFile = path.join('fonts', req.params.fontStack, req.params.range) + '.pbf';
+  if (assetLocation.endsWith('.tar.co')) {
+    return serveFromCotar(req, assetLocation, targetFile, 'application/x-protobuf');
+  }
 
   try {
-    const filePath = fsa.join(assetLocation, path.join('fonts', req.params.fontStack, req.params.range)) + '.pbf';
+    const filePath = fsa.join(assetLocation, targetFile);
     const buf = await fsa.read(filePath);
 
-    return LambdaHttpResponse.ok().buffer(buf, 'application/x-protobuf');
+    const cacheKey = Etag.key(buf);
+    if (Etag.isNotModified(req, cacheKey)) return NotModified();
+
+    const response = LambdaHttpResponse.ok().buffer(buf, 'application/x-protobuf');
+    response.header(HttpHeader.ETag, cacheKey);
+    response.header(HttpHeader.CacheControl, 'public, max-age=604800, stale-while-revalidate=86400');
+    if (isGzip(buf)) response.header(HttpHeader.ContentEncoding, 'gzip');
+    return response;
   } catch (e: any) {
-    if (e.code === 404) return NotFound;
+    if (e.code === 404) return NotFound();
     throw e;
   }
 }
@@ -38,17 +52,25 @@ export async function getFonts(fontPath: string): Promise<string[]> {
   return [...fonts].sort();
 }
 
-export async function fontList(): Promise<LambdaHttpResponse> {
+export async function fontList(req: LambdaHttpRequest): Promise<LambdaHttpResponse> {
   const assetLocation = Env.get(Env.AssetLocation);
-  if (assetLocation == null) return NotFound;
+  if (assetLocation == null) return NotFound();
+
+  if (assetLocation.endsWith('.tar.co')) return serveFromCotar(req, assetLocation, 'fonts.json', 'application/json');
 
   try {
     const filePath = fsa.join(assetLocation, '/fonts');
     const fonts = await getFonts(filePath);
 
-    return LambdaHttpResponse.ok().buffer(JSON.stringify(fonts), 'application/json');
+    const cacheKey = Etag.key(fonts);
+    if (Etag.isNotModified(req, cacheKey)) return NotModified();
+
+    const response = LambdaHttpResponse.ok().buffer(JSON.stringify(fonts), 'application/json');
+    response.header(HttpHeader.ETag, cacheKey);
+    response.header(HttpHeader.CacheControl, 'public, max-age=604800, stale-while-revalidate=86400');
+    return response;
   } catch (e: any) {
-    if (e.code === 404) return NotFound;
+    if (e.code === 404) return NotFound();
     throw e;
   }
 }

package/src/routes/health.ts

@@ -1,27 +1,29 @@
-import { GoogleTms, Nztm2000QuadTms, ImageFormat } from '@basemaps/geo';
-import { TileDataXyz, TileType } from '@basemaps/shared';
+import { Config, ConfigTileSetRaster } from '@basemaps/config';
+import { GoogleTms, ImageFormat, Nztm2000QuadTms } from '@basemaps/geo';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import * as fs from 'fs';
 import * as path from 'path';
 import PixelMatch from 'pixelmatch';
 import Sharp from 'sharp';
 import url from 'url';
-import { TileSets } from '../tile.set.cache.js';
+import { TileXyz } from '../util/validate.js';
+import { TileXyzRaster } from './tile.xyz.raster.js';
 
-interface TestTile extends TileDataXyz {
+interface TestTile extends TileXyz {
   buf?: Buffer;
 }
 
 export const TestTiles: TestTile[] = [
-  { type: TileType.Tile, name: 'health', tileMatrix: GoogleTms, ext: ImageFormat.Png, x: 252, y: 156, z: 8 },
-  { type: TileType.Tile, name: 'health', tileMatrix: Nztm2000QuadTms, ext: ImageFormat.Png, x: 30, y: 33, z: 6 },
+  { tileSet: 'health', tileMatrix: GoogleTms, tileType: ImageFormat.Png, tile: { x: 252, y: 156, z: 8 } },
+  { tileSet: 'health', tileMatrix: Nztm2000QuadTms, tileType: ImageFormat.Png, tile: { x: 30, y: 33, z: 6 } },
 ];
 const TileSize = 256;
 
 export async function getTestBuffer(test: TestTile): Promise<Buffer> {
   if (Buffer.isBuffer(test.buf)) return test.buf;
+  const tile = test.tile;
 
-  const expectedFile = `static/expected_tile_${test.tileMatrix.identifier}_${test.x}_${test.y}_z${test.z}.${test.ext}`;
+  const expectedFile = `static/expected_tile_${test.tileMatrix.identifier}_${tile.x}_${tile.y}_z${tile.z}.${test.tileType}`;
   // Initiate test img buffer if not defined
   try {
     return await fs.promises.readFile(expectedFile);
@@ -33,7 +35,9 @@ export async function getTestBuffer(test: TestTile): Promise<Buffer> {
 }
 
 export async function updateExpectedTile(test: TestTile, newTileData: Buffer, difference: Buffer): Promise<void> {
-  const expectedFileName = `static/expected_tile_${test.tileMatrix.identifier}_${test.x}_${test.y}_z${test.z}.${test.ext}`;
+  const tile = test.tile;
+
+  const expectedFileName = `static/expected_tile_${test.tileMatrix.identifier}_${tile.x}_${tile.y}_z${tile.z}.${test.tileType}`;
   await fs.promises.writeFile(expectedFileName, newTileData);
   const imgPng = await Sharp(difference, { raw: { width: TileSize, height: TileSize, channels: 4 } })
     .png()
@@ -48,12 +52,12 @@ export async function updateExpectedTile(test: TestTile, newTileData: Buffer, di
  *
  * @throws LambdaHttpResponse for failure health test
  */
-export async function Health(req: LambdaHttpRequest): Promise<LambdaHttpResponse> {
+export async function healthGet(req: LambdaHttpRequest): Promise<LambdaHttpResponse> {
+  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) {
-    const tileSet = await TileSets.get('health', test.tileMatrix);
-    if (tileSet == null) throw new LambdaHttpResponse(500, 'TileSet: "health" not found');
     // Get the parse response tile to raw buffer
-    const response = await tileSet.tile(req, test);
+    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();
@@ -68,10 +72,7 @@ export async function Health(req: LambdaHttpRequest): Promise<LambdaHttpResponse
     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: { x: test.x, y: test.y, z: test.z } },
-        'Health:MissMatch',
-      );
+      req.log.error({ missMatchedPixels, projection: test.tileMatrix.identifier, xyz: test.tile }, 'Health:MissMatch');
       return new LambdaHttpResponse(500, 'TileSet does not match.');
     }
   }

package/src/routes/imagery.ts

@@ -1,12 +1,11 @@
 import { Config } from '@basemaps/config';
 import { fsa } from '@basemaps/shared';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
-import { createHash } from 'crypto';
 import { promisify } from 'util';
 import { gzip } from 'zlib';
-import { Router } from '../router.js';
-import { NotModified } from './response.js';
-import { TileEtag } from './tile.etag.js';
+import { isGzip } from '../util/cotar.serve.js';
+import { Etag } from '../util/etag.js';
+import { NotFound, NotModified } from '../util/response.js';
 
 const gzipP = promisify(gzip);
 
@@ -17,6 +16,10 @@ export function isAllowedFile(f: string): boolean {
   return false;
 }
 
+interface ImageryGet {
+  Params: { imageryId: string; fileName: string };
+}
+
 /**
  * Get metadata around the imagery such as the source bounding box or the bounding box of the COGS
  *
@@ -27,30 +30,30 @@ export function isAllowedFile(f: string): boolean {
  * - /v1/imagery/:imageryId/collection.json - STAC Collection
  * - /v1/imagery/:imageryId/15-32659-21603.json - STAC Item
  */
-export async function Imagery(req: LambdaHttpRequest): Promise<LambdaHttpResponse> {
-  const { rest } = Router.action(req);
-  const [imageryId, requestType] = rest;
-  if (!isAllowedFile(requestType)) return new LambdaHttpResponse(404, 'Not found');
+export async function imageryGet(req: LambdaHttpRequest<ImageryGet>): Promise<LambdaHttpResponse> {
+  const requestedFile = req.params.fileName;
+  if (!isAllowedFile(requestedFile)) return NotFound();
 
-  const imagery = await Config.Imagery.get(Config.Imagery.id(imageryId));
-  if (imagery == null) return new LambdaHttpResponse(404, 'Not found');
+  const imagery = await Config.Imagery.get(Config.Imagery.id(req.params.imageryId));
+  if (imagery == null) return NotFound();
 
-  const targetPath = fsa.join(imagery.uri, requestType);
+  const targetPath = fsa.join(imagery.uri, requestedFile);
 
   try {
     const buf = await fsa.read(targetPath);
-    const cacheKey = createHash('sha256').update(buf).digest('base64');
 
-    if (TileEtag.isNotModified(req, cacheKey)) return NotModified;
+    const cacheKey = Etag.key(buf);
+    if (Etag.isNotModified(req, cacheKey)) return NotModified();
 
     const response = new LambdaHttpResponse(200, 'ok');
     response.header(HttpHeader.ETag, cacheKey);
     response.header(HttpHeader.ContentEncoding, 'gzip');
-    response.buffer(await gzipP(buf), 'application/json');
+    response.header(HttpHeader.CacheControl, 'public, max-age=604800, stale-while-revalidate=86400');
+    response.buffer(isGzip(buf) ? buf : await gzipP(buf), 'application/json');
     req.set('bytes', buf.byteLength);
     return response;
   } catch (e) {
     req.log.warn({ targetPath }, 'ImageryMetadata:Failed');
-    return new LambdaHttpResponse(404, 'Not found');
+    return NotFound();
   }
 }

package/src/routes/ping.ts

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

package/src/routes/sprites.ts

@@ -1,8 +1,10 @@
 import { Env } from '@basemaps/shared';
 import { fsa } from '@chunkd/fs';
 import path from 'path';
-import { LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
-import { NotFound } from './response.js';
+import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import { NotFound, NotModified } from '../util/response.js';
+import { isGzip, serveFromCotar } from '../util/cotar.serve.js';
+import { Etag } from '../util/etag.js';
 
 interface SpriteGet {
   Params: {
@@ -14,36 +16,32 @@ const Extensions = new Map();
 Extensions.set('.png', 'image/png');
 Extensions.set('.json', 'application/json');
 
-/**
- * Does a buffer look like a gzipped document instead of raw json
- *
- * Determined by checking the first two bytes are the gzip magic bytes `0x1f 0x8b`
- *
- * @see https://en.wikipedia.org/wiki/Gzip
- *
- */
-function isGzip(b: Buffer): boolean {
-  return b[0] === 0x1f && b[1] === 0x8b;
-}
-
 export async function spriteGet(req: LambdaHttpRequest<SpriteGet>): Promise<LambdaHttpResponse> {
-  const spriteLocation = Env.get(Env.AssetLocation);
-  if (spriteLocation == null) return NotFound;
+  const assetLocation = Env.get(Env.AssetLocation);
+  if (assetLocation == null) return NotFound();
 
   const extension = path.extname(req.params.spriteName);
   const mimeType = Extensions.get(extension);
-  if (mimeType == null) return NotFound;
+  if (mimeType == null) return NotFound();
+
+  const targetFile = fsa.join('sprites', req.params.spriteName);
+  if (assetLocation.endsWith('.tar.co')) return serveFromCotar(req, assetLocation, targetFile, mimeType);
 
   try {
-    const filePath = fsa.join(spriteLocation, fsa.join('/sprites', req.params.spriteName));
+    const filePath = fsa.join(assetLocation, targetFile);
     req.set('target', filePath);
 
     const buf = await fsa.read(filePath);
-    const res = LambdaHttpResponse.ok().buffer(buf, mimeType);
-    if (isGzip(buf)) res.header('content-encoding', 'gzip');
-    return res;
+    const cacheKey = Etag.key(buf);
+    if (Etag.isNotModified(req, cacheKey)) return NotModified();
+
+    const response = LambdaHttpResponse.ok().buffer(buf, mimeType);
+    response.header(HttpHeader.ETag, cacheKey);
+    response.header(HttpHeader.CacheControl, 'public, max-age=604800, stale-while-revalidate=86400');
+    if (isGzip(buf)) response.header(HttpHeader.ContentEncoding, 'gzip');
+    return response;
   } catch (e: any) {
-    if (e.code === 404) return NotFound;
+    if (e.code === 404) return NotFound();
     throw e;
   }
 }

package/src/routes/tile.json.ts

@@ -1,36 +1,41 @@
 import { GoogleTms, TileJson, TileMatrixSet } from '@basemaps/geo';
-import { Env, extractTileMatrixSet } from '@basemaps/shared';
+import { Config, Env } from '@basemaps/shared';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
-import { Router } from '../router.js';
-import { TileSets } from '../tile.set.cache.js';
-import { getTileMatrixId } from '../wmts.capability.js';
-import { NotFound } from './response.js';
+import { NotFound } from '../util/response.js';
+import { Validate } from '../util/validate.js';
+
+export interface TileJsonGet {
+  Params: {
+    tileSet: string;
+    tileMatrix: string;
+  };
+}
 
-export async function tileJson(req: LambdaHttpRequest): Promise<LambdaHttpResponse> {
-  const { version, rest, name } = Router.action(req);
-  if (rest.length !== 3) return NotFound;
+export async function tileJsonGet(req: LambdaHttpRequest<TileJsonGet>): Promise<LambdaHttpResponse> {
+  const tileMatrix = Validate.getTileMatrixSet(req.params.tileMatrix);
+  if (tileMatrix == null) return NotFound();
 
-  const tileMatrix = extractTileMatrixSet(rest[1]);
-  if (tileMatrix == null) return NotFound;
+  const apiKey = Validate.apiKey(req);
 
   req.timer.start('tileset:load');
-  const tileSet = await TileSets.get(rest[0], tileMatrix);
+  const tileSet = await Config.TileSet.get(Config.TileSet.id(req.params.tileSet));
   req.timer.end('tileset:load');
-  if (tileSet == null) return NotFound;
+  if (tileSet == null) return NotFound();
+
+  const format = Validate.getRequestedFormats(req) ?? [tileSet.format];
 
-  const apiKey = Router.apiKey(req);
   const host = Env.get(Env.PublicUrlBase) ?? '';
 
   const tileUrl =
-    [host, version, name, tileSet.fullName, getTileMatrixId(tileMatrix), '{z}', '{x}', '{y}'].join('/') +
-    `.${tileSet.format}?api=${apiKey}`;
+    [host, 'v1', 'tiles', tileSet.name, tileMatrix.identifier, '{z}', '{x}', '{y}'].join('/') +
+    `.${format[0]}?api=${apiKey}`;
 
   const tileJson: TileJson = { tiles: [tileUrl], tilejson: '3.0.0' };
-  const maxZoom = TileMatrixSet.convertZoomLevel(tileSet.tileSet.maxZoom ?? 30, GoogleTms, tileMatrix, true);
-  const minZoom = TileMatrixSet.convertZoomLevel(tileSet.tileSet.minZoom ?? 0, GoogleTms, tileMatrix, true);
+  const maxZoom = TileMatrixSet.convertZoomLevel(tileSet.maxZoom ?? 30, GoogleTms, tileMatrix, true);
+  const minZoom = TileMatrixSet.convertZoomLevel(tileSet.minZoom ?? 0, GoogleTms, tileMatrix, true);
 
-  if (tileSet.tileSet.maxZoom) tileJson.maxzoom = maxZoom;
-  if (tileSet.tileSet.minZoom) tileJson.minzoom = minZoom;
+  if (tileSet.maxZoom) tileJson.maxzoom = maxZoom;
+  if (tileSet.minZoom) tileJson.minzoom = minZoom;
 
   const json = JSON.stringify(tileJson);
   const data = Buffer.from(json);