@basemaps/lambda-tiler 6.15.0

package/src/__test__/xyz.test.ts

@@ -0,0 +1,333 @@
+import { ConfigProvider, StyleJson } from '@basemaps/config';
+import { TileMatrixSets } from '@basemaps/geo';
+import { Config, Env, LogConfig, VNodeParser } from '@basemaps/shared';
+import { round } from '@basemaps/test/build/rounding.js';
+import o from 'ospec';
+import { handleRequest } from '../index.js';
+import { TileComposer } from '../routes/tile.js';
+import { TileEtag } from '../routes/tile.etag.js';
+import { TileSets } from '../tile.set.cache.js';
+import { FakeTileSet, mockRequest, Provider } from './xyz.util.js';
+import sinon from 'sinon';
+const sandbox = sinon.createSandbox();
+
+const TileSetNames = ['aerial', 'aerial@head', 'aerial@beta', '01E7PJFR9AMQFJ05X9G7FQ3XMW'];
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+o.spec('LambdaXyz', () => {
+  /** Generate mock ALBEvent */
+
+  let rasterMock = o.spy();
+  const generateMock = o.spy(() => 'foo');
+  const rasterMockBuffer = Buffer.from([1]);
+  const origTileEtag = TileEtag.generate;
+  const origCompose = TileComposer.compose;
+
+  const apiKey = 'd01f7w7rnhdzg0p7fyrc9v9ard1';
+  const apiKeyHeader = { 'x-linz-api-key': 'd01f7w7rnhdzg0p7fyrc9v9ard1' };
+
+  o.beforeEach(() => {
+    LogConfig.disable();
+    // tileMock = o.spy(() => tileMockData) as any;
+    rasterMock = o.spy(() => {
+      return {
+        buffer: rasterMockBuffer,
+      };
+    }) as any;
+
+    TileEtag.generate = generateMock;
+    TileComposer.compose = rasterMock as any;
+
+    const allMatrix = [...TileMatrixSets.All.values()];
+    for (const tileSetName of TileSetNames) {
+      for (const tileMatrix of allMatrix) {
+        const tileSet = new FakeTileSet(tileSetName, tileMatrix);
+        TileSets.add(tileSet);
+        tileSet.getTiffsForTile = (): [] => [];
+        tileSet.initTiffs = async () => [];
+      }
+    }
+
+    (Config.Provider as any).get = async (): Promise<ConfigProvider> => Provider;
+  });
+
+  o.afterEach(() => {
+    TileSets.cache.clear();
+    TileComposer.compose = origCompose;
+    TileEtag.generate = origTileEtag;
+    sandbox.restore();
+  });
+
+  o('should export handler', async () => {
+    const base = await import('../index.js');
+    o(typeof base.handler).equals('function');
+  });
+
+  TileSetNames.forEach((tileSetName) => {
+    o(`should generate a tile 0,0,0 for ${tileSetName}.png`, async () => {
+      o.timeout(200);
+      const request = mockRequest(`/v1/tiles/${tileSetName}/global-mercator/0/0/0.png`, 'get', apiKeyHeader);
+      const res = await handleRequest(request);
+      o(res.status).equals(200);
+      o(res.header('content-type')).equals('image/png');
+      o(res.header('eTaG')).equals('foo');
+      o(res.body).equals(rasterMockBuffer.toString('base64'));
+
+      // Validate the session information has been set correctly
+      o(request.logContext['tileSet']).equals(tileSetName);
+      o(request.logContext['xyz']).deepEquals({ x: 0, y: 0, z: 0 });
+      o(round(request.logContext['location'])).deepEquals({ lat: 0, lon: 0 });
+    });
+  });
+
+  o('should generate a tile 0,0,0 for webp', async () => {
+    const request = mockRequest('/v1/tiles/aerial/3857/0/0/0.webp', 'get', apiKeyHeader);
+    const res = await handleRequest(request);
+    o(res.status).equals(200);
+    o(res.header('content-type')).equals('image/webp');
+    o(res.header('eTaG')).equals('foo');
+    o(res.body).equals(rasterMockBuffer.toString('base64'));
+
+    // Validate the session information has been set correctly
+    o(request.logContext['xyz']).deepEquals({ x: 0, y: 0, z: 0 });
+    o(round(request.logContext['location'])).deepEquals({ lat: 0, lon: 0 });
+  });
+
+  ['png', 'webp', 'jpeg'].forEach((fmt) => {
+    o(`should 200 with empty ${fmt} if a tile is out of bounds`, async () => {
+      // tiler.tile = async () => [];
+      const res = await handleRequest(
+        mockRequest(`/v1/tiles/aerial/global-mercator/0/0/0.${fmt}`, 'get', apiKeyHeader),
+      );
+      o(res.status).equals(200);
+      o(res.header('content-type')).equals(`image/${fmt}`);
+      o(rasterMock.calls.length).equals(1);
+    });
+  });
+
+  o('should 304 if a tile is not modified', async () => {
+    const key = 'foo';
+    const request = mockRequest('/v1/tiles/aerial/global-mercator/0/0/0.png', 'get', {
+      'if-none-match': key,
+      ...apiKeyHeader,
+    });
+    const res = await handleRequest(request);
+    o(res.status).equals(304);
+    o(res.header('eTaG')).equals(undefined);
+
+    o(rasterMock.calls.length).equals(0);
+    o(request.logContext['cache']).deepEquals({ key, match: key, hit: true });
+  });
+
+  o('should 404 if a tile is outside of the range', async () => {
+    try {
+      const res = await handleRequest(mockRequest('/v1/tiles/aerial/global-mercator/25/0/0.png', 'get', apiKeyHeader));
+      o(res.status).equals(404);
+    } catch (e: any) {
+      o(e.status).equals(404);
+    }
+    try {
+      const res = await handleRequest(mockRequest('/v1/tiles/aerial/2193/17/0/0.png', 'get', apiKeyHeader));
+      o(res.status).equals(404);
+    } catch (e: any) {
+      o(e.status).equals(404);
+    }
+  });
+
+  o.spec('WMTSCapabilities', () => {
+    const origPublicUrlBase = process.env[Env.PublicUrlBase];
+    o.after(() => {
+      process.env[Env.PublicUrlBase] = origPublicUrlBase;
+    });
+
+    o('should 304 if a xml is not modified', async () => {
+      o.timeout(1000);
+      const key = 'NuirTK8fozzCJV1iG1FznmdHhKvk6WaWuDhhEA1d40c=';
+      const request = mockRequest('/v1/tiles/WMTSCapabilities.xml', 'get', {
+        'if-none-match': key,
+        ...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(304);
+      o(rasterMock.calls.length).equals(0);
+
+      o(request.logContext['cache']).deepEquals({ key, match: key, hit: true });
+    });
+
+    o('should serve WMTSCapabilities for tile_set', async () => {
+      console.log('\n\nTestStart');
+      process.env[Env.PublicUrlBase] = 'https://tiles.test';
+
+      const request = mockRequest('/v1/tiles/aerial@beta/WMTSCapabilities.xml', 'get', apiKeyHeader);
+
+      const res = await handleRequest(request);
+      o(res.status).equals(200);
+      o(res.header('content-type')).equals('text/xml');
+      o(res.header('cache-control')).equals('max-age=0');
+
+      const body = Buffer.from(res.body ?? '', 'base64').toString();
+      o(body.slice(0, 100)).equals(
+        '<?xml version="1.0"?>\n' + '<Capabilities xmlns="http://www.opengis.net/wmts/1.0" xmlns:ows="http://www.op',
+      );
+
+      const vdom = await VNodeParser.parse(body);
+      const url = vdom.tags('ResourceURL').next().value;
+      o(url?.toString()).equals(
+        '<ResourceURL format="image/jpeg" resourceType="tile" ' +
+          `template="https://tiles.test/v1/tiles/aerial@beta/{TileMatrixSet}/{TileMatrix}/{TileCol}/{TileRow}.jpeg?api=${apiKey}" />`,
+      );
+    });
+  });
+
+  o.spec('tileJson', () => {
+    const origPublicUrlBase = process.env[Env.PublicUrlBase];
+    o.after(() => {
+      process.env[Env.PublicUrlBase] = origPublicUrlBase;
+    });
+
+    o('should 304 if a json is not modified', async () => {
+      const key = 'XecTdbcdjCyzB1MHOOQbrOkD2TTJ0ORh4JuXqhxXEE0=';
+      const request = mockRequest('/v1/tiles/tile.json', 'get', { 'if-none-match': key, ...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(304);
+      o(rasterMock.calls.length).equals(0);
+
+      o(request.logContext['cache']).deepEquals({ key, match: key, hit: true });
+    });
+
+    o('should serve tile json for tile_set', async () => {
+      process.env[Env.PublicUrlBase] = 'https://tiles.test';
+
+      const request = mockRequest('/v1/tiles/topolike/Google/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/topolike/Google/{z}/{x}/{y}.pbf?api=${apiKey}`],
+        minzoom: 0,
+        maxzoom: 15,
+        format: 'pbf',
+        tilejson: '2.0.0',
+      });
+    });
+  });
+
+  o.spec('styleJson', () => {
+    const origPublicUrlBase = process.env[Env.PublicUrlBase];
+    o.after(() => {
+      process.env[Env.PublicUrlBase] = origPublicUrlBase;
+    });
+
+    o('should not found style json', async () => {
+      process.env[Env.PublicUrlBase] = 'https://tiles.test';
+
+      const request = mockRequest('/v1/tiles/topolike/Google/style/topolike.json', 'get', apiKeyHeader);
+
+      sandbox.stub(Config.Style, 'get').resolves(null);
+
+      const res = await handleRequest(request);
+      o(res.status).equals(404);
+    });
+
+    o('should serve style json', async () => {
+      const host = 'https://tiles.test';
+      process.env[Env.PublicUrlBase] = host;
+
+      const request = mockRequest('/v1/tiles/topolike/Google/style/topolike.json', 'get', apiKeyHeader);
+
+      const fakeStyle: StyleJson = {
+        version: 8,
+        id: 'test',
+        name: 'topolike',
+        sources: {
+          basemaps_vector: {
+            type: 'vector',
+            url: `${host}/vector`,
+          },
+          basemaps_raster: {
+            type: 'raster',
+            tiles: [`${host}/raster`],
+          },
+          basemaps_raster_encode: {
+            type: 'raster',
+            tiles: [`${host}/raster/{z}/{x}/{y}.webp`], // Shouldn't encode the {}
+          },
+          test_vector: {
+            type: 'vector',
+            url: 'vector.url.co.nz',
+          },
+          test_raster: {
+            type: 'raster',
+            tiles: ['raster.url.co.nz'],
+          },
+        },
+        layers: [
+          {
+            layout: {
+              visibility: 'visible',
+            },
+            paint: {
+              'background-color': 'rgba(206, 229, 242, 1)',
+            },
+            id: 'Background',
+            type: 'background',
+            minzoom: 0,
+          },
+        ],
+        glyphs: 'glyphs',
+        sprite: 'sprite',
+        metadata: { id: 'test' },
+      };
+
+      const fakeRecord = {
+        id: 'st_topolike_production',
+        name: 'topolike',
+        style: fakeStyle,
+      };
+
+      sandbox.stub(Config.Style, 'get').resolves(fakeRecord as any);
+
+      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();
+      fakeStyle.sources.basemaps_vector = {
+        type: 'vector',
+        url: `${host}/vector?api=${apiKey}`,
+      };
+      fakeStyle.sources.basemaps_raster = {
+        type: 'raster',
+        tiles: [`${host}/raster?api=${apiKey}`],
+      };
+      fakeStyle.sources.basemaps_raster_encode = {
+        type: 'raster',
+        tiles: [`${host}/raster/{z}/{x}/{y}.webp?api=${apiKey}`],
+      };
+      o(JSON.parse(body)).deepEquals(fakeStyle);
+    });
+  });
+
+  ['/favicon.ico', '/index.html', '/foo/bar'].forEach((path) => {
+    o('should error on invalid paths: ' + path, async () => {
+      const res = await handleRequest(mockRequest(path, 'get', apiKeyHeader));
+      o(res.status).equals(404);
+    });
+  });
+});

package/src/__test__/xyz.util.ts

@@ -0,0 +1,58 @@
+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 { Context } from 'aws-lambda';
+
+export function mockRequest(path: string, method = 'get', headers: Record<string, string> = {}): LambdaHttpRequest {
+  return new LambdaAlbRequest(
+    {
+      requestContext: null as any,
+      httpMethod: method.toUpperCase(),
+      path,
+      headers,
+      body: null,
+      isBase64Encoded: false,
+    },
+    {} as Context,
+    LogConfig.get(),
+  );
+}
+
+export class FakeTileSet extends TileSetRaster {
+  constructor(name: string, tileMatrix: TileMatrixSet, title = `${name}:title`, description = `${name}:description`) {
+    super(name, tileMatrix);
+    this.tileSet = { title, description } as any;
+  }
+}
+
+export const Provider: ConfigProvider = {
+  createdAt: Date.now(),
+  name: 'main',
+  id: 'pv_main_production',
+  updatedAt: Date.now(),
+  version: 1,
+  serviceIdentification: {
+    accessConstraints: 'the accessConstraints',
+    description: 'the description',
+    fees: 'the fees',
+    title: 'the title',
+  },
+  serviceProvider: {
+    contact: {
+      address: {
+        city: 'the city',
+        country: 'the country',
+        deliveryPoint: 'the deliveryPoint',
+        email: 'email address',
+        postalCode: 'the postalCode',
+      },
+      individualName: 'the contact name',
+      phone: 'the phone',
+      position: 'the position',
+    },
+    name: 'the name',
+    site: 'https://example.provider.com',
+  },
+};

package/src/api.key.ts

@@ -0,0 +1,23 @@
+import * as ulid from 'ulid';
+
+const OneHourMs = 60 * 60 * 1000;
+const OneDayMs = 24 * OneHourMs;
+const MaxApiAgeMs = 91 * OneDayMs;
+
+export function isValidApiKey(apiKey?: string | null): boolean {
+  if (apiKey == null) return false;
+  if (!apiKey.startsWith('c') && !apiKey.startsWith('d')) return false;
+  const ulidId = apiKey.slice(1).toUpperCase();
+  try {
+    const ulidTime = ulid.decodeTime(ulidId);
+    if (apiKey.startsWith('d')) return true;
+
+    if (Date.now() - ulidTime > MaxApiAgeMs) {
+      return false;
+    }
+  } catch (e) {
+    return false;
+  }
+
+  return true;
+}

package/src/cli/dump.ts

@@ -0,0 +1,62 @@
+import { Nztm2000Tms } 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';
+import { TileRoute } from '../routes/tile.js';
+import { TileSets } from '../tile.set.cache.js';
+import { TileSet } from '../tile.set.js';
+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;
+
+/** Load a tileset form a file path otherwise default to the hard coded one from AWS */
+async function getTileSet(filePath?: string): Promise<TileSet> {
+  if (filePath != null) {
+    const tileSet = new TileSetLocal('local', filePath);
+    await tileSet.load();
+    TileSets.add(tileSet);
+    return tileSet;
+  }
+
+  const tileSet = await TileSets.get(tileSetName, tileMatrix);
+  if (tileSet == null) throw new Error('Missing');
+  return tileSet;
+}
+
+/**
+ * Utility to render a single tile then save it as a png
+ */
+async function main(): Promise<void> {
+  const logger = LogConfig.get();
+
+  const filePath = process.argv[2];
+  const tileSet = await getTileSet(filePath);
+
+  logger.info({ ...xyz, projection: tileMatrix.projection.code, tileMatrix: tileMatrix.identifier }, 'RenderTile');
+
+  const ctx = new LambdaAlbRequest(
+    {
+      httpMethod: 'get',
+      path: `/v1/tiles/${tileSet.fullName}/${tileMatrix.identifier}/${xyz.z}/${xyz.x}/${xyz.y}.${ext}`,
+    } as any,
+    {} as Context,
+    logger,
+  );
+
+  const tileData = await TileRoute.tile(ctx);
+
+  const headers: Record<string, any> = {};
+  for (const [key, value] of tileData.headers) headers[key] = value;
+
+  logger.info({ ...tileData, _body: tileData.body?.length, headers }, 'Done');
+  if (tileData._body != null) {
+    await fs.writeFile(`output_${xyz.x}_${xyz.y}_z${xyz.z}.${ext}`, tileData._body);
+  }
+}
+
+main().catch(console.error);

package/src/cli/serve.ts

@@ -0,0 +1,148 @@
+import { Epsg } from '@basemaps/geo';
+import { Env, LogConfig, LogType } from '@basemaps/shared';
+import { HttpHeader, LambdaAlbRequest, LambdaHttpRequest } from '@linzjs/lambda';
+import { Context } from 'aws-lambda';
+import express from 'express';
+import path from 'path';
+import 'source-map-support/register.js';
+import * as ulid from 'ulid';
+import url from 'url';
+import * as lambda from '../index.js';
+import { TileSets } from '../tile.set.cache.js';
+import { TileSetRaster } from '../tile.set.raster.js';
+import { WmtsCapabilities } from '../wmts.capability.js';
+import { Provider } from '../__test__/xyz.util.js';
+import { TileSetLocal } from './tile.set.local.js';
+const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
+
+const app = express();
+const port = Env.getNumber('PORT', 5050);
+
+async function handleRequest(
+  ctx: LambdaHttpRequest,
+  res: express.Response<any>,
+  startTime: number,
+  logger: LogType,
+  logInfo = {},
+): Promise<void> {
+  try {
+    const data = await lambda.handleRequest(ctx);
+    res.status(data.status);
+    if (data.headers) {
+      for (const [header, value] of data.headers) {
+        res.header(header, String(value));
+      }
+    }
+    if (data.status < 299 && data.status > 199) {
+      res.end(data.body);
+    } else {
+      res.end();
+    }
+    const duration = Date.now() - startTime;
+    logger.info({ ...ctx.logContext, ...logInfo, metrics: ctx.timer.metrics, status: data.status, duration }, 'Done');
+  } catch (e) {
+    logger.fatal({ ...ctx.logContext, err: e }, 'FailedToRender');
+    res.status(500);
+    res.end();
+  }
+}
+
+function useAws(): void {
+  app.get('/v1/*', async (req: express.Request, res: express.Response) => {
+    const startTime = Date.now();
+    const requestId = ulid.ulid();
+    const logger = LogConfig.get().child({ id: requestId });
+    const ctx = new LambdaAlbRequest(
+      {
+        httpMethod: 'get',
+        path: req.path,
+        queryStringParameters: req.query,
+      } as any,
+      { awsRequestId: requestId } as Context,
+      logger,
+    );
+    const ifNoneMatch = req.header(HttpHeader.IfNoneMatch);
+    if (ifNoneMatch != null) {
+      ctx.headers.set(HttpHeader.IfNoneMatch.toLowerCase(), ifNoneMatch);
+    }
+
+    await handleRequest(ctx, res, startTime, logger);
+  });
+
+  app.use(express.static(__dirname + '/../../../landing/dist/'));
+  LogConfig.get().info({ port, base: process.env[Env.PublicUrlBase], aws: process.env['AWS_PROFILE'] }, 'Listen');
+}
+
+async function useLocal(): Promise<void> {
+  let projection: number = Epsg.Google.code;
+  const filePath = process.argv[2];
+
+  const tileSetName = 'local';
+  if (filePath != null) {
+    const tileSet = new TileSetLocal(tileSetName, filePath);
+    await tileSet.load();
+    const tiffFiles = tileSet.tiffs.map((c) => c.source.uri).join(', ');
+    // TODO is there a better name for this
+    tileSet.setTitle(`Local - ${tiffFiles}`);
+    TileSets.add(tileSet);
+    LogConfig.get().info({ tileSets: [...TileSets.cache.keys()] }, 'LoadedTileSets');
+    projection = tileSet.tileMatrix.projection.code;
+  }
+
+  app.get('/v1/tiles/:imageryName/:projection/:z/:x/:y.:ext', async (req: express.Request, res: express.Response) => {
+    const startTime = Date.now();
+    const requestId = ulid.ulid();
+    const logger = LogConfig.get().child({ id: requestId });
+    const { x, y, z, ext, imageryName, projection } = req.params;
+    const ctx = new LambdaAlbRequest(
+      {
+        httpMethod: 'get',
+        path: `/v1/tiles/${imageryName}/${projection}/${z}/${x}/${y}.${ext}`,
+      } as any,
+      {} as Context,
+
+      logger,
+    );
+    await handleRequest(ctx, res, startTime, logger, { tile: { x, y, z } });
+  });
+
+  app.get('/v1/WMTSCapabilities.xml', async (req: express.Request, res: express.Response) => {
+    const startTime = Date.now();
+    const requestId = ulid.ulid();
+    const logger = LogConfig.get().child({ id: requestId });
+
+    const tileSets = await Promise.all([...TileSets.cache.values()].map((c) => c.value));
+    const xml = WmtsCapabilities.toXml(
+      Env.get(Env.PublicUrlBase) ?? '',
+      Provider,
+      tileSets.filter((f) => f?.type === 'raster') as TileSetRaster[],
+    );
+    res.header('content-type', 'application/xml');
+    res.send(xml);
+    res.end();
+    const duration = Date.now() - startTime;
+    logger.info({ path: req.url, duration, status: 200 }, 'Done');
+  });
+
+  app.use(express.static(__dirname + '/../../../landing/dist/'));
+
+  const url = Env.get(Env.PublicUrlBase) + `/?i=${tileSetName}&p=${projection}`;
+  const wmts = Env.get(Env.PublicUrlBase) + `/v1/WMTSCapabilities.xml`;
+  const xyz = Env.get(Env.PublicUrlBase) + `/v1/tiles/${tileSetName}/${projection}/{z}/{x}/{y}.png`;
+  LogConfig.get().info({ url, wmts, xyz }, 'Listen');
+}
+
+async function main(): Promise<void> {
+  if (Env.get(Env.PublicUrlBase) == null || Env.get(Env.PublicUrlBase) === '') {
+    process.env[Env.PublicUrlBase] = `http://localhost:${port}`;
+  }
+
+  if (process.argv.length < 3) {
+    useAws();
+  } else {
+    await useLocal();
+  }
+  await new Promise<void>((resolve) => app.listen(port, resolve));
+}
+
+main().catch((e) => console.error(e));

package/src/cli/tile.set.local.ts

@@ -0,0 +1,51 @@
+import { Epsg, GoogleTms, TileMatrixSets } from '@basemaps/geo';
+import { fsa, LogConfig } from '@basemaps/shared';
+import { CogTiff, TiffTagGeo } from '@cogeotiff/core';
+import { TileSetRaster } from '../tile.set.raster.js';
+
+function isTiff(fileName: string): boolean {
+  return fileName.toLowerCase().endsWith('.tif') || fileName.toLowerCase().endsWith('.tiff');
+}
+
+export class TileSetLocal extends TileSetRaster {
+  tiffs: CogTiff[];
+  filePath: string;
+  tileSet = {} as any;
+
+  constructor(name: string, path: string) {
+    super(name, GoogleTms);
+    this.filePath = path;
+    this.tileSet.name = name;
+    this.tileSet.title = name;
+    this.tileSet.projection = GoogleTms.projection.code;
+  }
+
+  setTitle(name: string): void {
+    this.tileSet.title = name;
+  }
+
+  async load(): Promise<boolean> {
+    if (this.tiffs != null) return true;
+
+    const fileList = isTiff(this.filePath) ? [this.filePath] : await fsa.toArray(fsa.list(this.filePath));
+    const files = fileList.filter(isTiff);
+    if (files.length === 0) throw new Error(`No tiff files found in ${this.filePath}`);
+
+    this.tiffs = files.map((filePath) => new CogTiff(fsa.source(filePath)));
+
+    // Read in the projection information
+    const [firstTiff] = this.tiffs;
+    await firstTiff.init(true);
+    const projection = Epsg.get(firstTiff.getImage(0).valueGeo(TiffTagGeo.ProjectedCSTypeGeoKey) as number);
+    this.tileMatrix = TileMatrixSets.get(projection);
+    LogConfig.get().info(
+      { path: this.filePath, count: this.tiffs.length, tileMatrix: this.tileMatrix.identifier },
+      'LoadedTiffs',
+    );
+    return true;
+  }
+
+  getTiffsForTile(): CogTiff[] {
+    return this.tiffs;
+  }
+}