@basemaps/lambda-tiler 6.24.0 → 6.25.0

package/src/__test__/tile.set.cache.test.ts

@@ -74,6 +74,17 @@ o.spec('TileSetCache', () => {
       if (subTileSetB == null || subTileSetB.type === TileSetType.Vector) throw new Error('null subTileSetB');
       o(subTileSetB.title).equals('parent Tasman rural 2018-19 0.3m');
     });
+
+    o('should not throw if child does not exist', async () => {
+      TileSets.add(new TileSetRaster('aerial@head', GoogleTms));
+
+      const parentTileSet = await TileSets.get('aerial@head', GoogleTms);
+      if (parentTileSet == null || parentTileSet.type === TileSetType.Vector) throw new Error('null parentTileSet');
+      parentTileSet.imagery = imgMap;
+
+      const subTileSet = await TileSets.get('aerial@head:fake', GoogleTms);
+      o(subTileSet).equals(null);
+    });
   });
 
   o.spec('loadTileSets', () => {

package/src/__test__/tile.style.json.test.ts

@@ -1,6 +1,7 @@
+import { StyleJson } from '@basemaps/config';
 import { Env } from '@basemaps/shared';
 import o from 'ospec';
-import { convertRelativeUrl } from '../routes/tile.style.json.js';
+import { convertRelativeUrl, convertStyleJson } from '../routes/tile.style.json.js';
 
 o.spec('TileStyleJson', () => {
   const host = 'https://tiles.test';
@@ -37,4 +38,58 @@ o.spec('TileStyleJson', () => {
   o('should not convert full urls', () => {
     o(convertRelativeUrl('https://foo.com/foo?bar=baz', 'abc')).equals('https://foo.com/foo?bar=baz');
   });
+
+  const baseStyleJson: StyleJson = {
+    version: 8,
+    id: 'style.id',
+    name: 'style.name',
+    sources: {
+      vector: { type: 'vector', url: '/v1/tiles/topographic/EPSG:3857/tile.json' },
+      raster: { type: 'raster', tiles: ['/v1/tiles/aerial/EPSG:3857/{z}/{x}/{y}.webp'] },
+    },
+    layers: [],
+    metadata: {},
+    glyphs: '/v1/glyphs',
+    sprite: '/v1/sprites',
+  };
+
+  o('should not destroy the original configuration', () => {
+    const apiKey = 'abc123';
+    const converted = convertStyleJson(baseStyleJson, apiKey);
+
+    o(converted.sources.vector).deepEquals({
+      type: 'vector',
+      url: 'https://tiles.test/v1/tiles/topographic/EPSG:3857/tile.json?api=abc123',
+    });
+    o(converted.sources.raster).deepEquals({
+      type: 'raster',
+      tiles: ['https://tiles.test/v1/tiles/aerial/EPSG:3857/{z}/{x}/{y}.webp?api=abc123'],
+    });
+
+    o(JSON.stringify(baseStyleJson).includes(apiKey)).equals(false);
+
+    const convertedB = convertStyleJson(baseStyleJson, '0x1234');
+    o(convertedB.sources.vector).deepEquals({
+      type: 'vector',
+      url: 'https://tiles.test/v1/tiles/topographic/EPSG:3857/tile.json?api=0x1234',
+    });
+    o(convertedB.sources.raster).deepEquals({
+      type: 'raster',
+      tiles: ['https://tiles.test/v1/tiles/aerial/EPSG:3857/{z}/{x}/{y}.webp?api=0x1234'],
+    });
+
+    o(JSON.stringify(baseStyleJson).includes('0x1234')).equals(false);
+    o(JSON.stringify(baseStyleJson).includes(apiKey)).equals(false);
+    o(JSON.stringify(baseStyleJson).includes('?api=')).equals(false);
+  });
+
+  o('should convert relative glyphs and sprites', () => {
+    const apiKey = '0x9f9f';
+    const converted = convertStyleJson(baseStyleJson, apiKey);
+    o(converted.sprite).equals('https://tiles.test/v1/sprites');
+    o(converted.glyphs).equals('https://tiles.test/v1/glyphs');
+
+    o(JSON.stringify(baseStyleJson).includes(apiKey)).equals(false);
+    o(JSON.stringify(baseStyleJson).includes('?api=')).equals(false);
+  });
 });

package/src/__test__/xyz.test.ts

@@ -1,5 +1,5 @@
 import { ConfigProvider, StyleJson } from '@basemaps/config';
-import { TileMatrixSets } from '@basemaps/geo';
+import { GoogleTms, Nztm2000QuadTms, TileMatrixSets } from '@basemaps/geo';
 import { Config, Env, LogConfig, VNodeParser } from '@basemaps/shared';
 import { round } from '@basemaps/test/build/rounding.js';
 import o from 'ospec';
@@ -8,7 +8,7 @@ import { handleRequest } from '../index.js';
 import { TileEtag } from '../routes/tile.etag.js';
 import { TileSets } from '../tile.set.cache.js';
 import { TileComposer } from '../tile.set.raster.js';
-import { FakeTileSet, mockRequest, Provider } from './xyz.util.js';
+import { FakeTileSet, FakeTileSetVector, mockRequest, Provider } from './xyz.util.js';
 
 const sandbox = sinon.createSandbox();
 
@@ -53,6 +53,8 @@ o.spec('LambdaXyz', () => {
       }
     }
 
+    TileSets.add(new FakeTileSetVector('topographic', GoogleTms));
+
     (Config.Provider as any).get = async (): Promise<ConfigProvider> => Provider;
   });
 
@@ -186,51 +188,80 @@ o.spec('LambdaXyz', () => {
   });
 
   o.spec('tileJson', () => {
-    o('should 304 if a json is not modified', async () => {
-      // delete process.env[Env.PublicUrlBase];
+    o('should 404 if invalid url is given', async () => {
+      const request = mockRequest('/v1/tiles/tile.json', 'get', apiKeyHeader);
 
-      const key = 'BBfQpNXA3Q90jlFrLSOZhxbvfOh7OpN1OEE+BylpbHw=';
-      const request = mockRequest('/v1/tiles/tile.json', 'get', { 'if-none-match': key, ...apiKeyHeader });
+      const res = await handleRequest(request);
+      o(res.status).equals(404);
+    });
+
+    o('should serve tile json for tile_set', async () => {
+      const request = mockRequest('/v1/tiles/aerial/NZTM2000Quad/tile.json', 'get', apiKeyHeader);
 
       const res = await handleRequest(request);
-      if (res.status === 200) {
-        o(res.header('eTaG')).equals(key); // this line is useful for discovering the new etag
-        return;
-      }
+      o(res.status).equals(200);
+      o(res.header('cache-control')).equals('no-store');
 
-      o(res.status).equals(304);
-      o(rasterMock.calls.length).equals(0);
+      const body = Buffer.from(res.body ?? '', 'base64').toString();
+      o(JSON.parse(body)).deepEquals({
+        tiles: [`https://tiles.test/v1/tiles/aerial/NZTM2000Quad/{z}/{x}/{y}.webp?api=${apiKey}`],
+        vector_layers: [],
+        tilejson: '3.0.0',
+      });
+    });
 
-      o(request.logContext['cache']).deepEquals({ key, match: key, hit: true });
+    o('should serve vector tiles', async () => {
+      const request = mockRequest('/v1/tiles/topographic/WebMercatorQuad/tile.json', 'get', apiKeyHeader);
+
+      const res = await handleRequest(request);
+      o(res.status).equals(200);
+
+      const body = Buffer.from(res.body ?? '', 'base64').toString();
+      o(JSON.parse(body)).deepEquals({
+        tiles: [`https://tiles.test/v1/tiles/topographic/EPSG:3857/{z}/{x}/{y}.pbf?api=${apiKey}`],
+        vector_layers: [],
+        tilejson: '3.0.0',
+      });
     });
 
-    o('should 200 if a invalid etag is given', async () => {
-      const key = 'ABCXecTdbcdjCyzB1MHOOQbrOkD2TTJ0ORh4JuXqhxXEE0=';
-      const request = mockRequest('/v1/tiles/tile.json', 'get', { 'if-none-match': key, ...apiKeyHeader });
+    o('should serve vector tiles with min/max zoom', async () => {
+      const fakeTileSet = new FakeTileSetVector('fake-vector', GoogleTms);
+      fakeTileSet.tileSet.maxZoom = 15;
+      fakeTileSet.tileSet.minZoom = 3;
+      TileSets.add(fakeTileSet);
+      const request = mockRequest('/v1/tiles/fake-vector/WebMercatorQuad/tile.json', 'get', apiKeyHeader);
 
       const res = await handleRequest(request);
       o(res.status).equals(200);
-      o(res.header('etag')).equals('BBfQpNXA3Q90jlFrLSOZhxbvfOh7OpN1OEE+BylpbHw=');
-      const out = JSON.parse(Buffer.from(res.body ?? '', 'base64').toString());
-      o(out.tiles[0].startsWith('https://tiles.test/v1/tiles/tile.json/undefined/{z}/{x}/{y}.pbf?api=')).equals(true);
-      o(request.logContext['cache']).deepEquals(undefined);
+
+      const body = Buffer.from(res.body ?? '', 'base64').toString();
+      o(JSON.parse(body)).deepEquals({
+        tiles: [`https://tiles.test/v1/tiles/fake-vector/EPSG:3857/{z}/{x}/{y}.pbf?api=${apiKey}`],
+        vector_layers: [],
+        maxzoom: 15,
+        minzoom: 3,
+        tilejson: '3.0.0',
+      });
     });
 
-    o('should serve tile json for tile_set', async () => {
-      const request = mockRequest('/v1/tiles/topographic/Google/tile.json', 'get', apiKeyHeader);
+    o('should serve convert zoom to tile matrix', async () => {
+      const fakeTileSet = new FakeTileSetVector('fake-vector', Nztm2000QuadTms);
+      fakeTileSet.tileSet.maxZoom = 15;
+      fakeTileSet.tileSet.minZoom = 1;
+      TileSets.add(fakeTileSet);
+
+      const request = mockRequest('/v1/tiles/fake-vector/NZTM2000Quad/tile.json', 'get', apiKeyHeader);
 
       const res = await handleRequest(request);
       o(res.status).equals(200);
-      o(res.header('content-type')).equals('application/json');
-      o(res.header('cache-control')).equals('max-age=120');
 
       const body = Buffer.from(res.body ?? '', 'base64').toString();
       o(JSON.parse(body)).deepEquals({
-        tiles: [`https://tiles.test/v1/tiles/topographic/Google/{z}/{x}/{y}.pbf?api=${apiKey}`],
+        tiles: [`https://tiles.test/v1/tiles/fake-vector/NZTM2000Quad/{z}/{x}/{y}.pbf?api=${apiKey}`],
+        vector_layers: [],
+        maxzoom: 13,
         minzoom: 0,
-        maxzoom: 15,
-        format: 'pbf',
-        tilejson: '2.0.0',
+        tilejson: '3.0.0',
       });
     });
   });

package/src/__test__/xyz.util.ts

@@ -1,9 +1,10 @@
 import { ConfigProvider } from '@basemaps/config';
 import { TileMatrixSet } from '@basemaps/geo';
-import { LambdaHttpRequest, LambdaAlbRequest } from '@linzjs/lambda';
 import { LogConfig } from '@basemaps/shared';
-import { TileSetRaster } from '../tile.set.raster.js';
+import { LambdaAlbRequest, LambdaHttpRequest } from '@linzjs/lambda';
 import { Context } from 'aws-lambda';
+import { TileSetRaster } from '../tile.set.raster.js';
+import { TileSetVector } from '../tile.set.vector.js';
 
 export function mockRequest(path: string, method = 'get', headers: Record<string, string> = {}): LambdaHttpRequest {
   return new LambdaAlbRequest(
@@ -27,6 +28,13 @@ export class FakeTileSet extends TileSetRaster {
   }
 }
 
+export class FakeTileSetVector extends TileSetVector {
+  constructor(name: string, tileMatrix: TileMatrixSet) {
+    super(name, tileMatrix);
+    this.tileSet = {} as any;
+  }
+}
+
 export const Provider: ConfigProvider = {
   createdAt: Date.now(),
   name: 'main',

package/src/cli/dump.ts

@@ -1,6 +1,5 @@
-import { Nztm2000Tms } from '@basemaps/geo';
+import { Nztm2000Tms, ImageFormat } from '@basemaps/geo';
 import { LogConfig } from '@basemaps/shared';
-import { ImageFormat } from '@basemaps/tiler';
 import { LambdaAlbRequest } from '@linzjs/lambda';
 import { Context } from 'aws-lambda';
 import { promises as fs } from 'fs';
@@ -12,7 +11,7 @@ import { TileSetLocal } from './tile.set.local.js';
 const xyz = { x: 0, y: 0, z: 0 };
 const tileMatrix = Nztm2000Tms;
 const tileSetName = 'aerial';
-const ext = ImageFormat.PNG;
+const ext = ImageFormat.Png;
 
 /** Load a tileset form a file path otherwise default to the hard coded one from AWS */
 async function getTileSet(filePath?: string): Promise<TileSet> {

package/src/import/imagery.find.ts

@@ -0,0 +1,60 @@
+import { AwsCredentials } from '@chunkd/source-aws-v2';
+import { fsa } from '@chunkd/fs';
+import { Env } from '@basemaps/shared';
+
+export interface RoleConfig {
+  bucket: string;
+  accountId: string;
+  roleArn: string;
+  externalId?: string;
+  roleSessionDuration?: number;
+}
+
+interface BucketConfig {
+  v: number;
+  buckets: RoleConfig[];
+  version: string;
+  package: string;
+  hash: string;
+  updatedAt: string;
+}
+
+export class RoleRegister {
+  /** Get all imagery source aws roles */
+  static async _loadRoles(): Promise<RoleConfig[]> {
+    const configBucket = Env.get(Env.AwsRoleConfigBucket);
+    if (configBucket == null) return [];
+    const configPath = `s3://${configBucket}/config.json`;
+    const config: BucketConfig = await fsa.readJson(configPath);
+    const roles = [];
+    for (const role of config.buckets) {
+      fsa.register(
+        's3://' + role.bucket,
+        AwsCredentials.fsFromRole(role.roleArn, role.externalId, role.roleSessionDuration),
+      );
+      roles.push(role);
+    }
+    return roles;
+  }
+
+  static _loadRolesPromise: Promise<RoleConfig[]> | undefined;
+  static loadRoles(): Promise<RoleConfig[]> {
+    if (RoleRegister._loadRolesPromise == null) RoleRegister._loadRolesPromise = this._loadRoles();
+    return RoleRegister._loadRolesPromise;
+  }
+
+  static async findRole(path: string): Promise<RoleConfig | undefined> {
+    const roles = await this.loadRoles();
+    return roles.find((f) => path.startsWith(`s3://${f.bucket}`));
+  }
+}
+
+/** Search for the imagery across all of our buckets */
+export async function findImagery(path: string): Promise<string[]> {
+  const files: string[] = [];
+  for await (const key of fsa.list(path)) {
+    const searchKey = key.toLowerCase();
+    if (searchKey.endsWith('.tif') || searchKey.endsWith('.tiff')) files.push(key);
+  }
+  return files;
+}

package/src/import/make.cog.ts

@@ -0,0 +1,29 @@
+import { JobCreationContext } from '@basemaps/cli/build/cog/cog.stac.job';
+import { TileMatrixSet } from '@basemaps/geo';
+import { Env } from '@basemaps/shared';
+import { RoleConfig } from './imagery.find.js';
+
+export async function getJobCreationContext(
+  path: string,
+  tileMatrix: TileMatrixSet,
+  role: RoleConfig,
+  files: string[],
+): Promise<JobCreationContext> {
+  const bucket = Env.get(Env.ImportImageryBucket);
+  if (bucket == null) throw new Error('Output AWS s3 bucket Not Found.');
+  const ctx: JobCreationContext = {
+    override: {
+      projection: tileMatrix.projection,
+      resampling: {
+        warp: 'bilinear',
+        overview: 'lanczos',
+      },
+    },
+    outputLocation: { type: 's3' as const, path: `s3://${bucket}` },
+    sourceLocation: { type: 's3', path, ...role, files: files },
+    batch: true,
+    tileMatrix,
+    oneCogCovering: false,
+  };
+  return ctx;
+}

package/src/index.ts

@@ -8,6 +8,7 @@ import { createHash } from 'crypto';
 import { Imagery } from './routes/imagery.js';
 import { Esri } from './routes/esri/rest.js';
 import { St } from './source.tracer.js';
+import { Import } from './routes/import.js';
 
 const app = new Router();
 
@@ -17,6 +18,7 @@ app.get('version', Version);
 app.get('tiles', Tiles);
 app.get('imagery', Imagery);
 app.get('esri', Esri);
+app.get('import', Import);
 
 let slowTimer: NodeJS.Timer | null = null;
 export async function handleRequest(req: LambdaHttpRequest): Promise<LambdaHttpResponse> {

package/src/routes/__test__/attribution.test.ts

@@ -45,6 +45,7 @@ const ExpectedJson = {
         ],
       },
       properties: {
+        title: 'Hastings-district urban 2011-13 0.1m',
         datetime: null,
         start_datetime: '2011-01-01T00:00:00Z',
         end_datetime: '2014-01-01T00:00:00Z',
@@ -73,6 +74,7 @@ const ExpectedJson = {
         ],
       },
       properties: {
+        title: 'Hastings-district urban 2013-14 0.1m',
         datetime: null,
         start_datetime: '2013-01-01T00:00:00Z',
         end_datetime: '2015-01-01T00:00:00Z',
@@ -101,6 +103,7 @@ const ExpectedJson = {
         ],
       },
       properties: {
+        title: 'Hastings-district urban 2015-17 0.1m',
         datetime: null,
         start_datetime: '2015-01-01T00:00:00Z',
         end_datetime: '2018-01-01T00:00:00Z',
@@ -129,6 +132,7 @@ const ExpectedJson = {
         ],
       },
       properties: {
+        title: 'Hastings-district urban 2017-18 0.1m',
         datetime: null,
         start_datetime: '2017-01-01T00:00:00Z',
         end_datetime: '2019-01-01T00:00:00Z',

package/src/routes/__test__/health.test.ts

@@ -21,6 +21,7 @@ const ctx: LambdaHttpRequest = new LambdaAlbRequest(
 );
 
 o.spec('health', async () => {
+  o.specTimeout(1000);
   const sandbox = sinon.createSandbox();
 
   const tileSet = new TileSetRaster('health', GoogleTms);
@@ -57,8 +58,6 @@ o.spec('health', async () => {
   // Prepare mock test tile response based on the static test tiles
 
   o('Should give a 200 response', async () => {
-    o.timeout(500);
-
     // Given ... a series good get tile response
     const callback = sandbox.stub(tileSet, 'tile');
     callback.onCall(0).resolves(Response1);
@@ -73,7 +72,6 @@ o.spec('health', async () => {
   });
 
   o('Should return mis-match tile response', async () => {
-    o.timeout(500);
     // Given ... a bad get tile response for second get tile
     const callback = sandbox.stub(tileSet, 'tile');
     callback.onCall(0).resolves(Response1);

package/src/routes/attribution.ts

@@ -173,6 +173,7 @@ async function tileSetAttribution(tileSet: TileSetRaster): Promise<AttributionSt
         coordinates: createCoordinates(bbox, im.files, proj),
       },
       properties: {
+        title: titleizeImageryName(im.name),
         datetime: null,
         start_datetime: interval[0][0],
         end_datetime: interval[0][1],

package/src/routes/health.ts

@@ -1,6 +1,5 @@
-import { GoogleTms, Nztm2000QuadTms } from '@basemaps/geo';
+import { GoogleTms, Nztm2000QuadTms, ImageFormat } from '@basemaps/geo';
 import { TileDataXyz, TileType } from '@basemaps/shared';
-import { ImageFormat } from '@basemaps/tiler';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import * as fs from 'fs';
 import * as path from 'path';
@@ -14,8 +13,8 @@ interface TestTile extends TileDataXyz {
 }
 
 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 },
+  { 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 },
 ];
 const TileSize = 256;
 

package/src/routes/import.ts

@@ -0,0 +1,66 @@
+import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import { Config, Const, fsa } from '@basemaps/shared';
+import { createHash } from 'crypto';
+import { findImagery, RoleRegister } from '../import/imagery.find.js';
+import { Nztm2000Tms, TileMatrixSets } from '@basemaps/geo';
+import { getJobCreationContext } from '../import/make.cog.js';
+import { ConfigProcessingJob, ConfigProviderDynamo } from '@basemaps/config';
+import { CogJobFactory } from '@basemaps/cli';
+
+/**
+ * Trigger import imagery job by this endpoint
+ *
+ * @example
+ * - /v1/import?path=s3://linz-imagery-staging/2022-03/wellington_rural_2022_delivery_1
+ */
+export async function Import(req: LambdaHttpRequest): Promise<LambdaHttpResponse> {
+  const path = req.query.get('path');
+  const projection = req.query.get('p');
+
+  // Parse projection as target, default to process both NZTM2000Quad
+  let targetTms = Nztm2000Tms;
+  if (projection != null) {
+    const tileMatrix = TileMatrixSets.find(projection);
+    if (tileMatrix == null) return new LambdaHttpResponse(404, 'Target projection Not found');
+    targetTms = tileMatrix;
+  }
+
+  // Find the imagery from s3
+  if (path == null || !path.startsWith('s3://')) return new LambdaHttpResponse(500, 'Invalid s3 path');
+  const role = await RoleRegister.findRole(path);
+  if (role == null) return new LambdaHttpResponse(500, 'Unable to Access the bucket');
+  const files = await findImagery(path);
+  if (files.length === 0) return new LambdaHttpResponse(404, 'Imagery Not Found');
+
+  // Prepare Cog jobs
+  const ctx = await getJobCreationContext(path, targetTms, role, files);
+
+  const id = createHash('sha256').update(JSON.stringify(ctx)).digest('base64');
+  const jobId = Config.ProcessingJob.id(id);
+  let jobConfig = await Config.ProcessingJob.get(jobId);
+  if (jobConfig == null) {
+    // Add id back to JobCreationContext
+    ctx.override!.id = id;
+    ctx.outputLocation.path = fsa.join(ctx.outputLocation.path, id);
+
+    // Start processing job
+    await CogJobFactory.create(ctx);
+    jobConfig = {
+      id: jobId,
+      name: path,
+      status: 'processing',
+    } as ConfigProcessingJob;
+
+    const config = new ConfigProviderDynamo(Const.TileMetadata.TableName);
+    await config.ProcessingJob.put(jobConfig);
+  }
+
+  const json = JSON.stringify(jobConfig);
+  const data = Buffer.from(json);
+
+  const response = new LambdaHttpResponse(200, 'ok');
+  response.header(HttpHeader.CacheControl, 'no-store');
+  response.buffer(data, 'application/json');
+  req.set('bytes', data.byteLength);
+  return response;
+}

package/src/routes/tile.json.ts

@@ -1,43 +1,42 @@
-import { Env } from '@basemaps/shared';
+import { GoogleTms, TileJson, TileMatrixSet } from '@basemaps/geo';
+import { Env, extractTileMatrixSet } from '@basemaps/shared';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
-import { createHash } from 'crypto';
 import { Router } from '../router.js';
-import { NotModified } from './response.js';
-import { TileEtag } from './tile.etag.js';
-
-export interface TileJson {
-  tiles: string[];
-  minzoom: number;
-  maxzoom: number;
-  format: string;
-  tilejson: string;
-}
+import { TileSets } from '../tile.set.cache.js';
+import { getTileMatrixId } from '../wmts.capability.js';
+import { NotFound } from './response.js';
 
 export async function tileJson(req: LambdaHttpRequest): Promise<LambdaHttpResponse> {
   const { version, rest, name } = Router.action(req);
+  if (rest.length !== 3) return NotFound;
+
+  const tileMatrix = extractTileMatrixSet(rest[1]);
+  if (tileMatrix == null) return NotFound;
+
+  req.timer.start('tileset:load');
+  const tileSet = await TileSets.get(rest[0], tileMatrix);
+  req.timer.end('tileset:load');
+  if (tileSet == null) return NotFound;
+
   const apiKey = Router.apiKey(req);
   const host = Env.get(Env.PublicUrlBase) ?? '';
-  const tileUrl = `${host}/${version}/${name}/${rest[0]}/${rest[1]}/{z}/{x}/{y}.pbf?api=${apiKey}`;
 
-  const tileJson: TileJson = {
-    tiles: [tileUrl],
-    minzoom: 0,
-    maxzoom: 15,
-    format: 'pbf',
-    tilejson: '2.0.0',
-  };
+  const tileUrl =
+    [host, version, name, tileSet.fullName, getTileMatrixId(tileMatrix), '{z}', '{x}', '{y}'].join('/') +
+    `.${tileSet.format}?api=${apiKey}`;
 
-  const json = JSON.stringify(tileJson);
+  const tileJson: TileJson = { tiles: [tileUrl], vector_layers: [], 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 data = Buffer.from(json);
-
-  const cacheKey = createHash('sha256').update(data).digest('base64');
+  if (tileSet.tileSet.maxZoom) tileJson.maxzoom = maxZoom;
+  if (tileSet.tileSet.minZoom) tileJson.minzoom = minZoom;
 
-  if (TileEtag.isNotModified(req, cacheKey)) return NotModified;
+  const json = JSON.stringify(tileJson);
+  const data = Buffer.from(json);
 
   const response = new LambdaHttpResponse(200, 'ok');
-  response.header(HttpHeader.ETag, cacheKey);
-  response.header(HttpHeader.CacheControl, 'max-age=120');
+  response.header(HttpHeader.CacheControl, 'no-store');
   response.buffer(data, 'application/json');
   req.set('bytes', data.byteLength);
   return response;

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

@@ -23,20 +23,15 @@ export function convertRelativeUrl(url?: string, apiKey?: string): string {
   return fullUrl.toString().replace(/%7B/g, '{').replace(/%7D/g, '}');
 }
 
-export async function styleJson(req: LambdaHttpRequest, fileName: string): Promise<LambdaHttpResponse> {
-  const apiKey = Router.apiKey(req);
-  if (apiKey == null) return new LambdaHttpResponse(400, 'Invalid API Key.');
-  const styleName = fileName.split('.json')[0];
-
-  // Get style Config from db
-  const dbId = Config.Style.id(styleName);
-  const styleConfig = await Config.Style.get(dbId);
-  if (styleConfig == null) return NotFound;
-
-  // Prepare sources and add linz source
-  const style = styleConfig.style;
-  const sources: Sources = {};
-  for (const [key, value] of Object.entries(style.sources)) {
+/**
+ * Create a new style json that has absolute urls to the current host and  API Keys where required
+ * @param style style to update
+ * @param apiKey api key to inject
+ * @returns new stylejson
+ */
+export function convertStyleJson(style: StyleJson, apiKey: string): StyleJson {
+  const sources: Sources = JSON.parse(JSON.stringify(style.sources));
+  for (const [key, value] of Object.entries(sources)) {
     if (value.type === 'vector') {
       value.url = convertRelativeUrl(value.url, apiKey);
     } else if (value.type === 'raster' && Array.isArray(value.tiles)) {
@@ -47,22 +42,31 @@ export async function styleJson(req: LambdaHttpRequest, fileName: string): Promi
     sources[key] = value;
   }
 
-  // prepare Style.json
-  const styleJson: StyleJson = {
-    /** Style.json version 8 */
+  return {
     version: 8,
     id: style.id,
     name: style.name,
     sources,
     layers: style.layers,
-    metadata: style.metadata || {},
+    metadata: style.metadata ?? {},
     glyphs: convertRelativeUrl(style.glyphs),
     sprite: convertRelativeUrl(style.sprite),
-  };
+  } as StyleJson;
+}
+
+export async function styleJson(req: LambdaHttpRequest, fileName: string): Promise<LambdaHttpResponse> {
+  const apiKey = Router.apiKey(req);
+  if (apiKey == null) return new LambdaHttpResponse(400, 'Invalid API Key.');
+  const styleName = fileName.split('.json')[0];
 
-  const json = JSON.stringify(styleJson);
+  // Get style Config from db
+  const dbId = Config.Style.id(styleName);
+  const styleConfig = await Config.Style.get(dbId);
+  if (styleConfig == null) return NotFound;
 
-  const data = Buffer.from(json);
+  // Prepare sources and add linz source
+  const style = convertStyleJson(styleConfig.style, apiKey);
+  const data = Buffer.from(JSON.stringify(style));
 
   const cacheKey = createHash('sha256').update(data).digest('base64');