@basemaps/lambda-tiler 6.19.0 → 6.20.0

package/src/routes/esri/rest.ts

@@ -0,0 +1,90 @@
+import { GoogleTms, TileMatrixSet } from '@basemaps/geo';
+import { tileXyzFromPath } from '@basemaps/shared';
+import { LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import { Router } from '../../router.js';
+import { TileSets } from '../../tile.set.cache.js';
+import { NotFound } from '../response.js';
+
+export async function vectorTileServer(
+  req: LambdaHttpRequest,
+  layerId: string,
+  tms: TileMatrixSet,
+): Promise<LambdaHttpResponse> {
+  if (tms.identifier !== GoogleTms.identifier) return NotFound;
+  const extent = {
+    xmin: tms.extent.x,
+    ymin: tms.extent.y,
+    xmax: tms.extent.right,
+    ymax: tms.extent.bottom,
+    // TODO where is wkid from
+    spatialReference: { wkid: 102100, latestWkid: tms.projection.code },
+  };
+
+  const res = new LambdaHttpResponse(200, 'ok');
+  res.json({
+    currentVersion: 10.4,
+    name: layerId,
+    capabilities: 'TilesOnly',
+    type: 'indexedVector',
+    tileMap: 'tilemap',
+    defaultStyles: 'resources/styles',
+    tiles: ['tiles/{z}/{x}/{y}.pbf'],
+    exportTilesAllowed: false,
+    maxExportTilesCount: 0,
+    initialExtent: extent,
+    fullExtent: extent,
+    minScale: tms.zooms[0].scaleDenominator,
+    maxScale: tms.zooms[tms.zooms.length - 1].scaleDenominator,
+    tileInfo: {
+      // TODO are all the pbf 256x256?
+      rows: 256,
+      cols: 256,
+      dpi: 96,
+      format: 'pbf',
+      origin: { x: tms.extent.x, y: tms.extent.bottom },
+      spatialReference: { wkid: 102100, latestWkid: tms.projection.code },
+      lods: tms.zooms.map((c, i) => {
+        return {
+          level: i,
+          scale: c.scaleDenominator,
+          resolution: c.scaleDenominator * 0.28e-3,
+        };
+      }),
+    },
+    resourceInfo: {
+      styleVersion: 8,
+      tileCompression: 'gzip',
+      cacheInfo: { storageInfo: { packetSize: 128, storageFormat: 'compactV2' } },
+    },
+  });
+  return res;
+}
+
+/**
+ * /v1/esri/services/:layerId/VectorTileServer
+ *
+ * @example http://localhost:5000/v1/esri/services/topographic/VectorTileServer
+ */
+export async function Esri(req: LambdaHttpRequest): Promise<LambdaHttpResponse> {
+  const { rest } = Router.action(req);
+  if (rest[0] !== 'services') return NotFound;
+  const layerId = rest[1];
+  if (layerId == null) return NotFound;
+
+  const serviceId = rest[2];
+  if (serviceId !== 'VectorTileServer') return NotFound;
+  if (rest.length === 3) return vectorTileServer(req, layerId, GoogleTms);
+
+  if (rest[rest.length - 1].endsWith('.pbf')) {
+    const generatedPath = [layerId, GoogleTms.identifier, ...rest.slice(rest.length - 3)];
+    const xyz = tileXyzFromPath(generatedPath);
+    if (xyz == null) return NotFound;
+    req.timer.start('tileset:load');
+    const tileSet = await TileSets.get(xyz.name, xyz.tileMatrix);
+    req.timer.end('tileset:load');
+    if (tileSet == null) return NotFound;
+    return await tileSet.tile(req, xyz);
+  }
+
+  return new LambdaHttpResponse(200, 'ok');
+}

package/src/routes/imagery.ts

@@ -5,8 +5,8 @@ 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 { NotModified } from './tile.js';
 
 const gzipP = promisify(gzip);
 
@@ -18,6 +18,8 @@ function isAllowedFile(f: string): boolean {
 
 /**
  * Get metadata around the imagery such as the source bounding box or the bounding box of the COGS
+ *
+ * @example
  * - /v1/imagery/:imageryId/source.geojson
  * - /v1/imagery/:imageryId/covering.geojson
  */

package/src/routes/response.ts

@@ -0,0 +1,4 @@
+import { LambdaHttpResponse } from '@linzjs/lambda';
+
+export const NotFound = new LambdaHttpResponse(404, 'Not Found');
+export const NotModified = new LambdaHttpResponse(304, 'Not modified');

package/src/routes/tile.json.ts

@@ -0,0 +1,44 @@
+import { Env } 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;
+}
+
+export async function tileJson(req: LambdaHttpRequest): Promise<LambdaHttpResponse> {
+  const { version, rest, name } = Router.action(req);
+  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 json = JSON.stringify(tileJson);
+
+  const data = Buffer.from(json);
+
+  const cacheKey = createHash('sha256').update(data).digest('base64');
+
+  if (TileEtag.isNotModified(req, cacheKey)) return NotModified;
+
+  const response = new LambdaHttpResponse(200, 'ok');
+  response.header(HttpHeader.ETag, cacheKey);
+  response.header(HttpHeader.CacheControl, 'max-age=120');
+  response.buffer(data, 'application/json');
+  req.set('bytes', data.byteLength);
+  return response;
+}

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

@@ -0,0 +1,77 @@
+import { Sources, StyleJson } from '@basemaps/config';
+import { Config, Env } from '@basemaps/shared';
+import { fsa } from '@chunkd/fs';
+import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import { createHash } from 'crypto';
+import { URL } from 'url';
+import { Router } from '../router.js';
+import { NotFound, NotModified } from './response.js';
+import { TileEtag } from './tile.etag.js';
+
+/**
+ * Convert relative URLS into a full hostname url
+ * @param url possible url to update
+ * @param apiKey ApiKey to append with ?api= if required
+ * @returns Updated Url or empty string if url is empty
+ */
+export function convertRelativeUrl(url?: string, apiKey?: string): string {
+  if (url == null) return '';
+  const host = Env.get(Env.PublicUrlBase) ?? '';
+  if (!url.startsWith('/')) return url; // Not relative ignore
+  const fullUrl = new URL(fsa.join(host, url));
+  if (apiKey) fullUrl.searchParams.set('api', apiKey);
+  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)) {
+    if (value.type === 'vector') {
+      value.url = convertRelativeUrl(value.url, apiKey);
+    } else if (value.type === 'raster' && Array.isArray(value.tiles)) {
+      for (let i = 0; i < value.tiles.length; i++) {
+        value.tiles[i] = convertRelativeUrl(value.tiles[i], apiKey);
+      }
+    }
+    sources[key] = value;
+  }
+
+  // prepare Style.json
+  const styleJson: StyleJson = {
+    /** Style.json version 8 */
+    version: 8,
+    id: style.id,
+    name: style.name,
+    sources,
+    layers: style.layers,
+    metadata: style.metadata || {},
+    glyphs: convertRelativeUrl(style.glyphs),
+    sprite: convertRelativeUrl(style.sprite),
+  };
+
+  const json = JSON.stringify(styleJson);
+
+  const data = Buffer.from(json);
+
+  const cacheKey = createHash('sha256').update(data).digest('base64');
+
+  if (TileEtag.isNotModified(req, cacheKey)) return NotModified;
+
+  const response = new LambdaHttpResponse(200, 'ok');
+  response.header(HttpHeader.ETag, cacheKey);
+  response.header(HttpHeader.CacheControl, 'no-store');
+  response.buffer(data, 'application/json');
+  req.set('bytes', data.byteLength);
+  return response;
+}

package/src/routes/tile.ts

@@ -1,185 +1,13 @@
-import { Sources, StyleJson } from '@basemaps/config';
-import { TileMatrixSet } from '@basemaps/geo';
-import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
-import { Config, Env, setNameAndProjection, TileSetName, tileWmtsFromPath, tileXyzFromPath } from '@basemaps/shared';
-import { TileMakerSharp } from '@basemaps/tiler-sharp';
-import { createHash } from 'crypto';
+import { LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import { isValidApiKey } from '../api.key.js';
-import { TileSets } from '../tile.set.cache.js';
-import { TileSetRaster } from '../tile.set.raster.js';
-import { WmtsCapabilities } from '../wmts.capability.js';
-import { attribution } from './attribution.js';
-import { TileEtag } from './tile.etag.js';
 import { Router } from '../router.js';
-import { ValidateTilePath } from '../validate.js';
-import { URL } from 'url';
-import { fsa } from '@chunkd/fs';
-
-export const TileComposer = new TileMakerSharp(256);
-
-export const NotFound = new LambdaHttpResponse(404, 'Not Found');
-export const NotModified = new LambdaHttpResponse(304, 'Not modified');
-
-export interface TileJson {
-  tiles: string[];
-  minzoom: number;
-  maxzoom: number;
-  format: string;
-  tilejson: string;
-}
-
-export const TileRoute = {
-  async tile(req: LambdaHttpRequest): Promise<LambdaHttpResponse> {
-    const action = Router.action(req);
-    const xyzData = tileXyzFromPath(action.rest);
-    if (xyzData == null) return NotFound;
-    ValidateTilePath.validate(req, xyzData);
-
-    req.timer.start('tileset:load');
-    const tileSet = await TileSets.get(xyzData.name, xyzData.tileMatrix);
-    req.timer.end('tileset:load');
-    if (tileSet == null) return NotFound;
-
-    const res = await tileSet.tile(req, xyzData);
-    return res;
-  },
-
-  async wmtsLoadTileSets(name: string, tileMatrix: TileMatrixSet | null): Promise<TileSetRaster[]> {
-    if (tileMatrix != null) {
-      const ts = await TileSets.get(name, tileMatrix);
-      if (ts == null || ts.isVector()) return [];
-      return [ts];
-    }
-    if (name === '') name = TileSetName.aerial;
-    return (await TileSets.getAll(name, tileMatrix)).filter((f) => f.type === 'raster') as TileSetRaster[];
-  },
-
-  async wmts(req: LambdaHttpRequest): Promise<LambdaHttpResponse> {
-    const action = Router.action(req);
-    const wmtsData = tileWmtsFromPath(action.rest);
-    if (wmtsData == null) return NotFound;
-    setNameAndProjection(req, wmtsData);
-    const host = Env.get(Env.PublicUrlBase) ?? '';
-
-    req.timer.start('tileset:load');
-    const tileSets = await TileRoute.wmtsLoadTileSets(wmtsData.name, wmtsData.tileMatrix);
-    req.timer.end('tileset:load');
-    if (tileSets.length === 0) return NotFound;
-
-    const providerId = Config.Provider.id('linz');
-    const provider = await Config.Provider.get(providerId);
-    if (provider == null) return NotFound;
-
-    const apiKey = Router.apiKey(req);
-    const xml = WmtsCapabilities.toXml(host, provider, tileSets, apiKey);
-    if (xml == null) return NotFound;
-
-    const data = Buffer.from(xml);
-
-    const cacheKey = createHash('sha256').update(data).digest('base64');
-    if (TileEtag.isNotModified(req, cacheKey)) return NotModified;
-
-    const response = new LambdaHttpResponse(200, 'ok');
-    response.header(HttpHeader.ETag, cacheKey);
-    response.header(HttpHeader.CacheControl, 'max-age=0');
-    response.buffer(data, 'text/xml');
-    req.set('bytes', data.byteLength);
-    return response;
-  },
-
-  async tileJson(req: LambdaHttpRequest): Promise<LambdaHttpResponse> {
-    const { version, rest, name } = Router.action(req);
-    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 json = JSON.stringify(tileJson);
-
-    const data = Buffer.from(json);
-
-    const cacheKey = createHash('sha256').update(data).digest('base64');
-
-    if (TileEtag.isNotModified(req, cacheKey)) return NotModified;
-
-    const response = new LambdaHttpResponse(200, 'ok');
-    response.header(HttpHeader.ETag, cacheKey);
-    response.header(HttpHeader.CacheControl, 'max-age=120');
-    response.buffer(data, 'application/json');
-    req.set('bytes', data.byteLength);
-    return response;
-  },
-
-  async 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 host = Env.get(Env.PublicUrlBase) ?? '';
-
-    // 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)) {
-      if (value.type === 'vector') {
-        if (value.url.startsWith('/')) {
-          const url = new URL(fsa.join(host, value.url));
-          url.searchParams.set('api', apiKey);
-          value.url = url.toString().replace(/%7B/g, '{').replace(/%7D/g, '}');
-        }
-      } else if (value.type === 'raster' && Array.isArray(value.tiles)) {
-        for (let i = 0; i < value.tiles.length; i++) {
-          const tile = value.tiles[i];
-          if (tile.startsWith('/')) {
-            const url = new URL(fsa.join(host, tile));
-            url.searchParams.set('api', apiKey);
-            value.tiles[i] = url.toString().replace(/%7B/g, '{').replace(/%7D/g, '}');
-          }
-        }
-      }
-      sources[key] = value;
-    }
-
-    // prepare Style.json
-    const styleJson: StyleJson = {
-      /** Style.json version 8 */
-      version: 8,
-      id: style.id,
-      name: style.name,
-      sources,
-      layers: style.layers,
-      metadata: style.metadata || {},
-      glyphs: style.glyphs || '',
-      sprite: style.sprite || '',
-    };
-
-    const json = JSON.stringify(styleJson);
-
-    const data = Buffer.from(json);
-
-    const cacheKey = createHash('sha256').update(data).digest('base64');
-
-    if (TileEtag.isNotModified(req, cacheKey)) return NotModified;
+import { attribution } from './attribution.js';
+import { NotFound } from './response.js';
+import { tileJson } from './tile.json.js';
+import { styleJson } from './tile.style.json.js';
+import { wmts } from './tile.wmts.js';
+import { tileXyz } from './tile.xyz.js';
 
-    const response = new LambdaHttpResponse(200, 'ok');
-    response.header(HttpHeader.ETag, cacheKey);
-    response.header(HttpHeader.CacheControl, 'no-store');
-    response.buffer(data, 'application/json');
-    req.set('bytes', data.byteLength);
-    return response;
-  },
-};
 export async function Tiles(req: LambdaHttpRequest): Promise<LambdaHttpResponse> {
   const { rest } = Router.action(req);
   if (rest.length < 1) return NotFound;
@@ -188,8 +16,8 @@ export async function Tiles(req: LambdaHttpRequest): Promise<LambdaHttpResponse>
 
   const fileName = rest[rest.length - 1].toLowerCase();
   if (fileName === 'attribution.json') return attribution(req);
-  if (fileName === 'wmtscapabilities.xml') return TileRoute.wmts(req);
-  if (fileName === 'tile.json') return TileRoute.tileJson(req);
-  if (fileName.endsWith('json') && rest[rest.length - 2] === 'style') return TileRoute.styleJson(req, fileName);
-  return TileRoute.tile(req);
+  if (fileName === 'wmtscapabilities.xml') return wmts(req);
+  if (fileName === 'tile.json') return tileJson(req);
+  if (fileName.endsWith('json') && rest[rest.length - 2] === 'style') return styleJson(req, fileName);
+  return tileXyz(req);
 }

package/src/routes/tile.wmts.ts

@@ -0,0 +1,59 @@
+import { Config } from '@basemaps/config';
+import { TileMatrixSet } from '@basemaps/geo';
+import { Env, TileSetName, tileWmtsFromPath } from '@basemaps/shared';
+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 { WmtsCapabilities } from '../wmts.capability.js';
+import { NotFound, NotModified } from './response.js';
+import { TileEtag } from './tile.etag.js';
+
+/**
+ * Serve a WMTS request
+ *
+ * /v1/tiles/:tileSet/:tileMatrixSet/WMTSCapabilities.xml
+ * @example `/v1/tiles/aerial/NZTM2000Quad/WMTSCapabilities.xml`
+ */
+export async function wmts(req: LambdaHttpRequest): Promise<LambdaHttpResponse> {
+  const action = Router.action(req);
+  const wmtsData = tileWmtsFromPath(action.rest);
+  if (wmtsData == null) return NotFound;
+  const host = Env.get(Env.PublicUrlBase) ?? '';
+
+  req.timer.start('tileset:load');
+  const tileSets = await wmtsLoadTileSets(wmtsData.name, wmtsData.tileMatrix);
+  req.timer.end('tileset:load');
+  if (tileSets.length === 0) return NotFound;
+
+  const providerId = Config.Provider.id('linz');
+  const provider = await Config.Provider.get(providerId);
+  if (provider == null) return NotFound;
+
+  const apiKey = Router.apiKey(req);
+  const xml = WmtsCapabilities.toXml(host, provider, tileSets, apiKey);
+  if (xml == null) return NotFound;
+
+  const data = Buffer.from(xml);
+
+  const cacheKey = createHash('sha256').update(data).digest('base64');
+  if (TileEtag.isNotModified(req, cacheKey)) return NotModified;
+
+  const response = new LambdaHttpResponse(200, 'ok');
+  response.header(HttpHeader.ETag, cacheKey);
+  response.header(HttpHeader.CacheControl, 'max-age=0');
+  response.buffer(data, 'text/xml');
+  req.set('bytes', data.byteLength);
+  return response;
+}
+
+async function wmtsLoadTileSets(name: string, tileMatrix: TileMatrixSet | null): Promise<TileSetRaster[]> {
+  if (tileMatrix != null) {
+    const ts = await TileSets.get(name, tileMatrix);
+    if (ts == null || ts.isVector()) return [];
+    return [ts];
+  }
+  if (name === '') name = TileSetName.aerial;
+  return (await TileSets.getAll(name, tileMatrix)).filter((f) => f.type === 'raster') as TileSetRaster[];
+}

package/src/routes/tile.xyz.ts

@@ -0,0 +1,30 @@
+import { tileXyzFromPath } from '@basemaps/shared';
+import { LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import { Router } from '../router.js';
+import { TileSets } from '../tile.set.cache.js';
+import { ValidateTilePath } from '../validate.js';
+import { NotFound } from './response.js';
+
+/**
+ * Serve a tile
+ *
+ * /v1/tiles/:tileSet/:tileMatrixSet/:z/:x/:y.:tileType
+ *
+ * @example
+ *  Vector Tile `/v1/tiles/topographic/EPSG:3857/2/1/1.pbf`
+ *  Raster Tile `/v1/tiles/aerial/EPSG:3857/6/0/38.webp`
+ * @returns
+ */
+export async function tileXyz(req: LambdaHttpRequest): Promise<LambdaHttpResponse> {
+  const action = Router.action(req);
+  const xyzData = tileXyzFromPath(action.rest);
+  if (xyzData == null) return NotFound;
+  ValidateTilePath.validate(req, xyzData);
+
+  req.timer.start('tileset:load');
+  const tileSet = await TileSets.get(xyzData.name, xyzData.tileMatrix);
+  req.timer.end('tileset:load');
+  if (tileSet == null) return NotFound;
+
+  return await tileSet.tile(req, xyzData);
+}

package/src/tile.set.raster.ts

@@ -2,17 +2,20 @@ import { ConfigImagery, ConfigLayer, ConfigTileSetRaster, TileSetNameParser, Til
 import { Bounds, Epsg, Tile, TileMatrixSet, TileMatrixSets } from '@basemaps/geo';
 import { Config, Env, fsa, LogType, TileDataXyz, titleizeImageryName, VectorFormat } from '@basemaps/shared';
 import { Tiler } from '@basemaps/tiler';
+import { TileMakerSharp } from '@basemaps/tiler-sharp';
 import { CogTiff } from '@cogeotiff/core';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import { Metrics } from '@linzjs/metrics';
 import pLimit from 'p-limit';
+import { NotFound, NotModified } from './routes/response.js';
 import { TileEtag } from './routes/tile.etag.js';
-import { NotFound, NotModified, TileComposer } from './routes/tile.js';
 import { TiffCache } from './tiff.cache.js';
 import { TileSetHandler } from './tile.set.js';
 
 const LoadingQueue = pLimit(Env.getNumber(Env.TiffConcurrency, 5));
 
+export const TileComposer = new TileMakerSharp(256);
+
 export interface TileSetResponse {
   buffer: Buffer;
   metrics: Metrics;

package/src/tile.set.vector.ts

@@ -2,7 +2,7 @@ import { ConfigTileSetVector, TileSetType } from '@basemaps/config';
 import { fsa, TileDataXyz, VectorFormat } from '@basemaps/shared';
 import { Cotar } from '@cotar/core';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
-import { NotFound } from './routes/tile.js';
+import { NotFound } from './routes/response.js';
 import { TileSetHandler } from './tile.set.js';
 
 class CotarCache {