@basemaps/lambda-tiler 6.24.1 → 6.26.0

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,76 @@ 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}`],
+        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}`],
+        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}`],
+        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}`],
+        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,67 @@
+import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import { Config, 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 } 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(400, `Invalid s3 path: ${path}`);
+  const role = await RoleRegister.findRole(path);
+  if (role == null) return new LambdaHttpResponse(403, 'Unable to Access the s3 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.outputLocation.path = fsa.join(ctx.outputLocation.path, id);
+
+    // Insert Processing job config
+    jobConfig = {
+      id: jobId,
+      name: path,
+      status: 'processing',
+    } as ConfigProcessingJob;
+
+    if (Config.ProcessingJob.isWriteable()) await Config.ProcessingJob.put(jobConfig);
+    else return new LambdaHttpResponse(403, 'Unable to insert the Processing Job config');
+
+    // Start processing job
+    await CogJobFactory.create(ctx);
+  }
+
+  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], 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/tile.set.cache.ts

@@ -75,7 +75,7 @@ export class TileSetCache {
     }
 
     const ts = new TileSetVector(name, tileMatrix);
-    ts.tileSet = tileSet;
+    await ts.init(tileSet);
     this.tileSets.set(tileSetId, ts);
     return ts;
   }
@@ -97,7 +97,11 @@ export class TileSetCache {
       if (nameComp.layer != null) {
         parent.components.name = nameComp.name;
       } else if (parent.imagery != null && parent.imagery.size > 1) {
-        for (const imageId of parent.imagery.keys()) tileSets.push(parent.child(imageId));
+        for (const imageId of parent.imagery.keys()) {
+          const childImg = parent.child(imageId);
+          if (childImg == null) continue;
+          tileSets.push(childImg);
+        }
       }
     }
     return tileSets.sort((a, b) => a.title.localeCompare(b.title));

package/src/tile.set.raster.ts

@@ -6,8 +6,8 @@ import {
   TileSetNameParser,
   TileSetType,
 } from '@basemaps/config';
-import { Bounds, Epsg, Tile, TileMatrixSet, TileMatrixSets } from '@basemaps/geo';
-import { Config, Env, fsa, LogType, TileDataXyz, titleizeImageryName, VectorFormat } from '@basemaps/shared';
+import { Bounds, Epsg, ImageFormat, Tile, TileMatrixSet, TileMatrixSets, VectorFormat } from '@basemaps/geo';
+import { Config, Env, fsa, LogType, TileDataXyz, titleizeImageryName } from '@basemaps/shared';
 import { Tiler } from '@basemaps/tiler';
 import { TileMakerSharp } from '@basemaps/tiler-sharp';
 import { CogTiff } from '@cogeotiff/core';
@@ -83,6 +83,11 @@ export class TileSetRaster {
     return this.extentOverride ?? this.tileMatrix.extent;
   }
 
+  /** Preferred default imagery format */
+  get format(): ImageFormat {
+    return this.tileSet.format ?? ImageFormat.Webp;
+  }
+
   async init(record: ConfigTileSetRaster): Promise<void> {
     this.tileSet = record;
     this.imagery = await Config.getAllImagery(this.tileSet.layers, this.tileMatrix.projection);
@@ -208,11 +213,9 @@ export class TileSetRaster {
     return null;
   }
 
-  child(imgId: string): TileSetRaster {
+  child(imgId: string): TileSetRaster | null {
     const image = this.findImagery(imgId);
-    if (image == null) {
-      throw new Error('Failed to create child tile set ' + this.fullName + ' Missing imagery ' + imgId);
-    }
+    if (image == null) return null;
     const childName = TileSetNameParser.componentsToName({ ...this.components, layer: image.name });
     const child = new TileSetRaster(childName, this.tileMatrix);
     // use parent data as prototype for child;

package/src/tile.set.vector.ts

@@ -1,6 +1,6 @@
 import { ConfigTileSetVector, TileSetNameComponents, TileSetNameParser, TileSetType } from '@basemaps/config';
-import { TileMatrixSet } from '@basemaps/geo';
-import { fsa, TileDataXyz, VectorFormat } from '@basemaps/shared';
+import { TileMatrixSet, VectorFormat } from '@basemaps/geo';
+import { fsa, TileDataXyz } from '@basemaps/shared';
 import { Cotar } from '@cotar/core';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import { NotFound } from './routes/response.js';
@@ -34,6 +34,15 @@ export class TileSetVector {
     this.tileMatrix = tileMatrix;
   }
 
+  async init(record: ConfigTileSetVector): Promise<void> {
+    this.tileSet = record;
+  }
+
+  /** What format does tile set use */
+  get format(): VectorFormat {
+    return VectorFormat.MapboxVectorTiles;
+  }
+
   get id(): string {
     return TileSets.id(this.fullName, this.tileMatrix);
   }

package/src/wmts.capability.ts

@@ -23,7 +23,7 @@ function wgs84Extent(layer: TileSetRaster): BBox {
 /**
  * Default the tile matrix id to the projection of the TileMatrixSet
  */
-function getTileMatrixId(tileMatrix: TileMatrixSet): string {
+export function getTileMatrixId(tileMatrix: TileMatrixSet): string {
   // TODO this should really change everything to identifier
   if (tileMatrix.identifier === Nztm2000QuadTms.identifier) return Nztm2000QuadTms.identifier;
   return tileMatrix.projection.toEpsgString();