@basemaps/lambda-tiler 6.32.1 → 6.34.0

package/dist/node_modules/.package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@basemaps/lambda-tiler",
-  "version": "6.32.1",
+  "version": "6.34.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
@@ -226,9 +226,9 @@
       "integrity": "sha512-ONmRUqK7zj7DWX0D9ADe03wbwOBZxNAfF20PlGfCWQcD3+/MakShIHrMqx9YwPTfxDdF1zLeL+RGZiR9kGMLdg=="
     },
     "node_modules/node-abi": {
-      "version": "3.22.0",
-      "resolved": "https://registry.npmjs.org/node-abi/-/node-abi-3.22.0.tgz",
-      "integrity": "sha512-u4uAs/4Zzmp/jjsD9cyFYDXeISfUWaAVWshPmDZOFOv4Xl4SbzTXm53I04C2uRueYJ+0t5PEtLH/owbn2Npf/w==",
+      "version": "3.24.0",
+      "resolved": "https://registry.npmjs.org/node-abi/-/node-abi-3.24.0.tgz",
+      "integrity": "sha512-YPG3Co0luSu6GwOBsmIdGW6Wx0NyNDLg/hriIyDllVsNwnI6UeqaWShxC3lbH4LtEQUgoLP3XR1ndXiDAWvmRw==",
       "dependencies": {
         "semver": "^7.3.5"
       },

package/dist/node_modules/node-abi/abi_registry.json

@@ -202,9 +202,16 @@
   },
   {
     "abi": "107",
-    "future": true,
+    "future": false,
     "lts": false,
     "runtime": "electron",
     "target": "20.0.0-alpha.1"
+  },
+  {
+    "abi": "109",
+    "future": true,
+    "lts": false,
+    "runtime": "electron",
+    "target": "21.0.0-alpha.1"
   }
 ]

package/dist/node_modules/node-abi/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-abi",
-  "version": "3.22.0",
+  "version": "3.24.0",
   "description": "Get the Node ABI for a given target and runtime, and vice versa.",
   "main": "index.js",
   "scripts": {

package/dist/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@basemaps/lambda-tiler",
-  "version": "6.32.1",
+  "version": "6.34.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@basemaps/lambda-tiler",
-      "version": "6.32.1",
+      "version": "6.34.0",
       "license": "MIT",
       "dependencies": {
         "sharp": "0.30.7"
@@ -237,9 +237,9 @@
       "integrity": "sha512-ONmRUqK7zj7DWX0D9ADe03wbwOBZxNAfF20PlGfCWQcD3+/MakShIHrMqx9YwPTfxDdF1zLeL+RGZiR9kGMLdg=="
     },
     "node_modules/node-abi": {
-      "version": "3.22.0",
-      "resolved": "https://registry.npmjs.org/node-abi/-/node-abi-3.22.0.tgz",
-      "integrity": "sha512-u4uAs/4Zzmp/jjsD9cyFYDXeISfUWaAVWshPmDZOFOv4Xl4SbzTXm53I04C2uRueYJ+0t5PEtLH/owbn2Npf/w==",
+      "version": "3.24.0",
+      "resolved": "https://registry.npmjs.org/node-abi/-/node-abi-3.24.0.tgz",
+      "integrity": "sha512-YPG3Co0luSu6GwOBsmIdGW6Wx0NyNDLg/hriIyDllVsNwnI6UeqaWShxC3lbH4LtEQUgoLP3XR1ndXiDAWvmRw==",
       "dependencies": {
         "semver": "^7.3.5"
       },
@@ -647,9 +647,9 @@
       "integrity": "sha512-ONmRUqK7zj7DWX0D9ADe03wbwOBZxNAfF20PlGfCWQcD3+/MakShIHrMqx9YwPTfxDdF1zLeL+RGZiR9kGMLdg=="
     },
     "node-abi": {
-      "version": "3.22.0",
-      "resolved": "https://registry.npmjs.org/node-abi/-/node-abi-3.22.0.tgz",
-      "integrity": "sha512-u4uAs/4Zzmp/jjsD9cyFYDXeISfUWaAVWshPmDZOFOv4Xl4SbzTXm53I04C2uRueYJ+0t5PEtLH/owbn2Npf/w==",
+      "version": "3.24.0",
+      "resolved": "https://registry.npmjs.org/node-abi/-/node-abi-3.24.0.tgz",
+      "integrity": "sha512-YPG3Co0luSu6GwOBsmIdGW6Wx0NyNDLg/hriIyDllVsNwnI6UeqaWShxC3lbH4LtEQUgoLP3XR1ndXiDAWvmRw==",
       "requires": {
         "semver": "^7.3.5"
       }

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@basemaps/lambda-tiler",
-  "version": "6.32.1",
+  "version": "6.34.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/linz/basemaps.git",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@basemaps/lambda-tiler",
-  "version": "6.32.1",
+  "version": "6.34.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/linz/basemaps.git",
@@ -22,10 +22,10 @@
   "types": "./build/index.d.ts",
   "license": "MIT",
   "dependencies": {
-    "@basemaps/config": "^6.32.1",
+    "@basemaps/config": "^6.34.0",
     "@basemaps/geo": "^6.32.1",
     "@basemaps/lambda": "^6.7.0",
-    "@basemaps/shared": "^6.32.1",
+    "@basemaps/shared": "^6.34.0",
     "@basemaps/tiler": "^6.32.1",
     "@basemaps/tiler-sharp": "^6.32.1",
     "@chunkd/fs": "^8.4.0",
@@ -59,5 +59,5 @@
     "@types/sharp": "^0.30.3",
     "pretty-json-log": "^1.0.0"
   },
-  "gitHead": "4544a7d98667c5274142f1bb6bf61f02e4e5f618"
+  "gitHead": "1685fa12be66df74bc64d7f76b7355390980a43f"
 }

package/src/__tests__/xyz.util.ts

@@ -17,10 +17,15 @@ export function mockRequest(path: string, method = 'get', headers: Record<string
   );
 }
 
-export function mockUrlRequest(path: string, query = '', headers: Record<string, unknown> = {}): LambdaHttpRequest {
+export function mockUrlRequest(
+  path: string,
+  query = '',
+  headers: Record<string, unknown> = {},
+  method?: string,
+): LambdaHttpRequest {
   return new LambdaUrlRequest(
     {
-      requestContext: { http: { method: 'GET' } },
+      requestContext: { http: { method: method ? method.toUpperCase() : 'GET' } },
       headers,
       rawPath: encodeURI(path),
       rawQueryString: query,

package/src/arcgis/__tests__/arcgis.style.json.test.ts

@@ -0,0 +1,153 @@
+import { Config, StyleJson } from '@basemaps/config';
+import { Env } from '@basemaps/shared';
+import o from 'ospec';
+import { createSandbox } from 'sinon';
+import { handler } from '../../index.js';
+import { FakeData } from '../../__tests__/config.data.js';
+import { Api, mockRequest, mockUrlRequest } from '../../__tests__/xyz.util.js';
+
+o.spec('v1/arcgis/rest/services/', () => {
+  const host = 'https://tiles.test';
+  const sandbox = createSandbox();
+
+  o.before(() => {
+    process.env[Env.PublicUrlBase] = host;
+  });
+  o.afterEach(() => sandbox.restore());
+  o('should not found tile set', async () => {
+    const request = mockRequest('/v1/arcgis/rest/services/topographic/VectorTileServer/root.json', 'get', Api.header);
+
+    sandbox.stub(Config.TileSet, 'get').resolves(null);
+
+    const res = await handler.router.handle(request);
+    o(res.status).equals(404);
+  });
+
+  o('should not found style', async () => {
+    const request = mockRequest('/v1/arcgis/rest/services/topographic/VectorTileServer/root.json', 'get', Api.header);
+
+    sandbox.stub(Config.TileSet, 'get').resolves(FakeData.tileSetVector('topographic'));
+    sandbox.stub(Config.Style, 'get').resolves(null);
+
+    const res = await handler.router.handle(request);
+    o(res.status).equals(404);
+  });
+
+  const fakeStyle: StyleJson = {
+    version: 8,
+    id: 'test',
+    name: 'topographic',
+    sources: {
+      basemaps_vector: {
+        type: 'vector',
+        url: `/vector`,
+      },
+      basemaps_raster: {
+        type: 'raster',
+        tiles: [`/raster`],
+      },
+    },
+    layers: [
+      {
+        source: 'basemaps_vector',
+        layout: {
+          visibility: 'visible',
+        },
+        paint: {
+          'background-color': 'rgba(206, 229, 242, 1)',
+        },
+        id: 'Background-vector',
+        type: 'background',
+        minzoom: 0,
+      },
+      {
+        source: 'basemaps_raster',
+        layout: {
+          visibility: 'visible',
+        },
+        paint: {
+          'background-color': 'rgba(222, 229, 132, 1)',
+        },
+        id: 'Background-raster',
+        type: 'background',
+        minzoom: 0,
+      },
+    ],
+    glyphs: '/glyphs',
+    sprite: '/sprite',
+    metadata: { id: 'test' },
+  };
+
+  const fakeRecord = {
+    id: 'st_topographic',
+    name: 'topographic',
+    style: fakeStyle,
+  };
+
+  o('should serve style json and remove the raster source and layers, then replace the vector url', async () => {
+    const request = mockRequest('/v1/arcgis/rest/services/topographic/VectorTileServer/root.json', 'get', Api.header);
+
+    sandbox.stub(Config.TileSet, 'get').resolves(FakeData.tileSetVector('topographic'));
+    sandbox.stub(Config.Style, 'get').resolves(fakeRecord as any);
+
+    const res = await handler.router.handle(request);
+    o(res.status).equals(200);
+    o(res.header('content-type')).equals('application/json');
+    o(res.header('cache-control')).equals('no-store');
+
+    const body = Buffer.from(res.body ?? '', 'base64').toString();
+    fakeStyle.sources.basemaps_vector = {
+      type: 'vector',
+      url: `${host}/v1/arcgis/rest/services/topographic/VectorTileServer?api=${Api.key}&f=json`,
+    };
+    delete fakeStyle.sources.basemaps_raster;
+    fakeStyle.layers = [fakeStyle.layers[0]];
+
+    fakeStyle.sprite = `${host}/sprite`;
+    fakeStyle.glyphs = `${host}/glyphs`;
+
+    o(JSON.parse(body)).deepEquals(fakeStyle);
+  });
+
+  o('should not found for raster tileset', async () => {
+    const request = mockRequest('/v1/arcgis/rest/services/raster/VectorTileServer/root.json', 'get', Api.header);
+
+    sandbox.stub(Config.TileSet, 'get').resolves(FakeData.tileSetRaster('raster'));
+    sandbox.stub(Config.Style, 'get').resolves(fakeRecord as any);
+
+    const res = await handler.router.handle(request);
+    o(res.status).equals(404);
+  });
+
+  o('should fine the new style with url query', async () => {
+    const request = mockUrlRequest(
+      '/v1/arcgis/rest/services/topographic/VectorTileServer/root.json',
+      'style=topolite',
+      Api.header,
+    );
+
+    sandbox.stub(Config.TileSet, 'get').resolves(FakeData.tileSetVector('topographic'));
+    sandbox
+      .stub(Config.Style, 'get')
+      .withArgs('st_topolite')
+      .resolves(fakeRecord as any);
+
+    const res = await handler.router.handle(request);
+    o(res.status).equals(200);
+    o(res.header('content-type')).equals('application/json');
+    o(res.header('cache-control')).equals('no-store');
+
+    const body = Buffer.from(res.body ?? '', 'base64').toString();
+    fakeStyle.sources.basemaps_vector = {
+      type: 'vector',
+      url: `${host}/v1/arcgis/rest/services/topographic/VectorTileServer?api=${Api.key}&f=json`,
+    };
+    delete fakeStyle.sources.basemaps_raster;
+    fakeStyle.layers = [fakeStyle.layers[0]];
+
+    fakeStyle.sprite = `${host}/sprite`;
+    fakeStyle.glyphs = `${host}/glyphs`;
+
+    o(JSON.parse(body)).deepEquals(fakeStyle);
+  });
+});

package/src/arcgis/__tests__/vector.tiler.server.test.ts

@@ -0,0 +1,61 @@
+import { Config } from '@basemaps/config';
+import { Env } from '@basemaps/shared';
+import o from 'ospec';
+import { createSandbox } from 'sinon';
+import { handler } from '../../index.js';
+import { FakeData } from '../../__tests__/config.data.js';
+import { Api, mockRequest, mockUrlRequest } from '../../__tests__/xyz.util.js';
+
+o.spec('v1/arcgis/rest/services/', () => {
+  const host = 'https://tiles.test';
+  const sandbox = createSandbox();
+
+  o.before(() => {
+    process.env[Env.PublicUrlBase] = host;
+  });
+  o.afterEach(() => sandbox.restore());
+  o('should not found tile set', async () => {
+    const request = mockUrlRequest('/v1/arcgis/rest/services/topographic/VectorTileServer', 'f=json', Api.header);
+
+    sandbox.stub(Config.TileSet, 'get').resolves(null);
+
+    const res = await handler.router.handle(request);
+    o(res.status).equals(404);
+  });
+  o('should return the vector tile server', async () => {
+    const request = mockUrlRequest('/v1/arcgis/rest/services/topographic/VectorTileServer', 'f=json', Api.header);
+
+    sandbox.stub(Config.TileSet, 'get').resolves(FakeData.tileSetVector('topographic'));
+
+    const res = await handler.router.handle(request);
+    o(res.status).equals(200);
+    o(res.header('content-type')).equals('application/json');
+    o(res.header('cache-control')).equals('no-store');
+
+    const body = JSON.parse(Buffer.from(res.body ?? '', 'base64').toString());
+    o(body.tiles[0]).equals(`${host}/v1/tiles/topographic/WebMercatorQuad/{z}/{x}/{y}.pbf?api=${Api.key}`);
+    o(body.tileInfo.lods.length).equals(17);
+  });
+  o('should not return with no f=json query', async () => {
+    const request = mockRequest('/v1/arcgis/rest/services/topographic/VectorTileServer', 'get', Api.header);
+
+    sandbox.stub(Config.TileSet, 'get').resolves(FakeData.tileSetVector('topographic'));
+
+    const res = await handler.router.handle(request);
+    o(res.status).equals(404);
+  });
+  o('should return ok for post request', async () => {
+    const request = mockUrlRequest(
+      '/v1/arcgis/rest/services/topographic/VectorTileServer',
+      'f=json',
+      Api.header,
+      'POST',
+    );
+
+    sandbox.stub(Config.TileSet, 'get').resolves(FakeData.tileSetVector('topographic'));
+
+    const res = await handler.router.handle(request);
+    o(res.status).equals(200);
+    o(res.body).deepEquals(`{"id":"${request.id}","correlationId":"${request.correlationId}","message":"ok"}`);
+  });
+});

package/src/arcgis/arcgis.info.ts

@@ -0,0 +1,26 @@
+import { Env } from '@basemaps/shared';
+import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import { Etag } from '../util/etag.js';
+import { NotFound, NotModified } from '../util/response.js';
+
+export async function arcgisInfoGet(req: LambdaHttpRequest): Promise<LambdaHttpResponse> {
+  const host = Env.get(Env.PublicUrlBase);
+  if (host == null) return NotFound();
+  const info = {
+    currentVersion: 10.1,
+    fullVersion: '10.1',
+    owningSystemUrl: host,
+  };
+
+  const json = JSON.stringify(info);
+  const data = Buffer.from(json);
+
+  const cacheKey = Etag.key(data);
+  if (Etag.isNotModified(req, cacheKey)) return NotModified();
+
+  const response = new LambdaHttpResponse(200, 'ok');
+  response.header(HttpHeader.CacheControl, 'public, max-age=604800, stale-while-revalidate=86400');
+  response.buffer(data, 'application/json');
+  req.set('bytes', data.byteLength);
+  return response;
+}

package/src/arcgis/arcgis.style.json.ts

@@ -0,0 +1,81 @@
+import { Config, Sources, StyleJson, TileSetType } from '@basemaps/config';
+import { Env, fsa } from '@basemaps/shared';
+import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import { convertRelativeUrl } from '../routes/tile.style.json.js';
+import { Etag } from '../util/etag.js';
+import { NotFound, NotModified } from '../util/response.js';
+import { Validate } from '../util/validate.js';
+
+interface StyleGet {
+  Params: {
+    tileSet: string;
+  };
+}
+
+function tileserverUrl(tileSet: string, apiKey: string): string {
+  const host = Env.get(Env.PublicUrlBase) ?? '';
+  const url = `/v1/arcgis/rest/services/${tileSet}/VectorTileServer`;
+  const fullUrl = new URL(fsa.join(host, url));
+  fullUrl.searchParams.set('api', apiKey);
+  fullUrl.searchParams.set('f', 'json');
+  return fullUrl.toString().replace(/%7B/g, '{').replace(/%7D/g, '}');
+}
+
+function convertStyleJson(tileSet: string, style: StyleJson, apiKey: string): StyleJson {
+  const sources: Sources = JSON.parse(JSON.stringify(style.sources));
+  // Only keep the vector layer and update the source url
+  for (const [key, value] of Object.entries(sources)) {
+    if (value.type === 'vector') {
+      value.url = tileserverUrl(tileSet, apiKey);
+      sources[key] = value;
+    } else {
+      delete sources[key];
+    }
+  }
+
+  // Remove all the not vector layers.
+  const layers = [];
+  for (const layer of style.layers) {
+    if (layer.source != null && !sources.hasOwnProperty(layer.source)) continue;
+    layers.push(layer);
+  }
+
+  return {
+    version: 8,
+    id: style.id,
+    name: style.name,
+    sources,
+    layers,
+    metadata: style.metadata ?? {},
+    glyphs: convertRelativeUrl(style.glyphs),
+    sprite: convertRelativeUrl(style.sprite),
+  } as StyleJson;
+}
+
+export async function arcgisStyleJsonGet(req: LambdaHttpRequest<StyleGet>): Promise<LambdaHttpResponse> {
+  const apiKey = Validate.apiKey(req);
+  const tileSet = await Config.TileSet.get(Config.TileSet.id(req.params.tileSet));
+  if (tileSet?.type !== TileSetType.Vector) return NotFound();
+
+  const style = req.query.get('style');
+  const styleName = style ? style : 'topographic'; // Defalut to topographic style
+
+  // 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 styleJson = convertStyleJson(tileSet.name, styleConfig.style, apiKey);
+  const data = Buffer.from(JSON.stringify(styleJson));
+
+  const cacheKey = Etag.key(data);
+  if (Etag.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/arcgis/vector.tile.server.ts

@@ -0,0 +1,78 @@
+import { Config, TileSetType } from '@basemaps/config';
+import { GoogleTms } from '@basemaps/geo';
+import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import { convertRelativeUrl } from '../routes/tile.style.json.js';
+import { NotFound } from '../util/response.js';
+import { Validate } from '../util/validate.js';
+
+/** Zoom level for the tilematrix which will be slice by 1 during the covertion to arcgis tileserve lods */
+const MaxTileMatrixZoom = 18;
+const MinTileMatrixZoom = 1;
+
+export interface VectorTileServer {
+  Params: {
+    tileSet: string;
+  };
+}
+
+export async function arcgisTileServerGet(req: LambdaHttpRequest<VectorTileServer>): Promise<LambdaHttpResponse> {
+  const tileSet = await Config.TileSet.get(Config.TileSet.id(req.params.tileSet));
+  if (tileSet?.type !== TileSetType.Vector) return NotFound();
+  const apiKey = Validate.apiKey(req);
+  const f = req.query.get('f');
+  if (f !== 'json') return NotFound();
+  const extent = {
+    xmin: GoogleTms.extent.x,
+    ymin: GoogleTms.extent.y,
+    xmax: GoogleTms.extent.right,
+    ymax: GoogleTms.extent.bottom,
+    // TODO where is wkid from
+    spatialReference: { wkid: 102100, latestWkid: GoogleTms.projection.code },
+  };
+  const vectorTileServer = {
+    currentVersion: 10.81,
+    name: tileSet.name,
+    capabilities: 'TilesOnly',
+    type: 'indexedVector',
+    defaultStyles: '',
+    tiles: [convertRelativeUrl(`/v1/tiles/${tileSet.name}/WebMercatorQuad/{z}/{x}/{y}.pbf`, apiKey)],
+    exportTilesAllowed: false,
+    maxExportTilesCount: 0,
+    initialExtent: extent,
+    fullExtent: extent,
+    minScale: 0.0,
+    maxScale: 0.0,
+    tileInfo: {
+      rows: 512,
+      cols: 512,
+      dpi: 96,
+      format: 'pbf',
+      origin: { x: GoogleTms.extent.x, y: GoogleTms.extent.bottom },
+      spatialReference: { wkid: 102100, latestWkid: GoogleTms.projection.code },
+      lods: GoogleTms.zooms.slice(MinTileMatrixZoom, MaxTileMatrixZoom).map((c, i) => {
+        return {
+          level: i,
+          resolution: c.scaleDenominator * 0.28e-3,
+          scale: c.scaleDenominator,
+        };
+      }),
+    },
+    maxzoom: 22,
+    minLOD: 0,
+    maxLOD: 15,
+    resourceInfo: {
+      styleVersion: 8,
+      tileCompression: 'gzip',
+      cacheInfo: { storageInfo: { packetSize: 128, storageFormat: 'compactV2' } },
+    },
+  };
+
+  const json = JSON.stringify(vectorTileServer, null, 2);
+  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/index.ts

@@ -1,5 +1,8 @@
-import { LogConfig } from '@basemaps/shared';
-import { LambdaHttpResponse, LambdaUrlRequest, lf } from '@linzjs/lambda';
+import { Env, LogConfig } from '@basemaps/shared';
+import { LambdaHttpResponse, lf } from '@linzjs/lambda';
+import { arcgisInfoGet } from './arcgis/arcgis.info.js';
+import { arcgisStyleJsonGet } from './arcgis/arcgis.style.json.js';
+import { arcgisTileServerGet } from './arcgis/vector.tile.server.js';
 import { tileAttributionGet } from './routes/attribution.js';
 import { fontGet, fontList } from './routes/fonts.js';
 import { healthGet } from './routes/health.js';
@@ -11,7 +14,8 @@ import { styleJsonGet } from './routes/tile.style.json.js';
 import { wmtsCapabilitiesGet } from './routes/tile.wmts.js';
 import { tileXyzGet } from './routes/tile.xyz.js';
 import { versionGet } from './routes/version.js';
-import { NotFound } from './util/response.js';
+import { assetProvider } from './util/assets.provider.js';
+import { NotFound, OkResponse } from './util/response.js';
 import { CoSources } from './util/source.cache.js';
 import { St } from './util/source.tracer.js';
 
@@ -20,11 +24,19 @@ export const handler = lf.http(LogConfig.get());
 handler.router.hook('request', (req) => {
   req.set('name', 'LambdaTiler');
 
+  // Set the asset location for asset provider
+  const assetLocation = Env.get(Env.AssetLocation);
+  assetProvider.set(assetLocation);
+
   // Reset the request tracing before every request
   St.reset();
 });
 
+let totalRequests = 0;
 handler.router.hook('response', (req, res) => {
+  totalRequests++;
+  req.set('requestsTotal', totalRequests); // Number of requests served by this lambda
+
   if (St.requests.length > 0) {
     // TODO this could be relaxed to every say 5% of requests if logging gets too verbose.
     req.set('requests', St.requests.slice(0, 100)); // limit to 100 requests (some tiles need 100s of requests)
@@ -36,17 +48,16 @@ handler.router.hook('response', (req, res) => {
     misses: CoSources.cache.misses,
     size: CoSources.cache.currentSize,
     resets: CoSources.cache.resets,
+    clears: CoSources.cache.clears,
     cacheA: CoSources.cache.cacheA.size,
     cacheB: CoSources.cache.cacheB.size,
   });
 
-  // FunctionURLs automatically inject CORS responses for us
-  if (!(req instanceof LambdaUrlRequest) && req.headers.has('origin')) {
-    res.header('access-control-allow-origin', '*');
-  }
+  // Force access-control-allow-origin to everything
+  res.header('access-control-allow-origin', '*');
 });
 
-// CORS is handled by function url hook so just return ok if the route exists
+// CORS is handled by response hook so just return ok if the route exists
 handler.router.options('*', (req) => {
   const route = handler.router.router.find('GET', req.path);
   if (route == null) return NotFound();
@@ -91,3 +102,9 @@ handler.router.get('/v1/attribution/:tileSet/:tileMatrix/summary.json', tileAttr
 handler.router.get('/v1/tiles/:tileSet/:tileMatrix/WMTSCapabilities.xml', wmtsCapabilitiesGet);
 handler.router.get('/v1/tiles/:tileSet/WMTSCapabilities.xml', wmtsCapabilitiesGet);
 handler.router.get('/v1/tiles/WMTSCapabilities.xml', wmtsCapabilitiesGet);
+
+// Arcgis Vector
+handler.router.get('/v1/arcgis/rest/services/:tileSet/VectorTileServer', arcgisTileServerGet);
+handler.router.post('/v1/arcgis/rest/services/:tileSet/VectorTileServer', OkResponse);
+handler.router.get('/v1/arcgis/rest/services/:tileSet/VectorTileServer/root.json', arcgisStyleJsonGet);
+handler.router.get('/v1/arcgis/rest/info', arcgisInfoGet);