@basemaps/lambda-tiler 7.11.0 → 7.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@basemaps/lambda-tiler",
-  "version": "7.11.0",
+  "version": "7.13.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/linz/basemaps.git",
@@ -22,12 +22,12 @@
   "types": "./build/index.d.ts",
   "license": "MIT",
   "dependencies": {
-    "@basemaps/config": "^7.11.0",
-    "@basemaps/config-loader": "^7.11.0",
-    "@basemaps/geo": "^7.11.0",
-    "@basemaps/shared": "^7.11.0",
-    "@basemaps/tiler": "^7.11.0",
-    "@basemaps/tiler-sharp": "^7.11.0",
+    "@basemaps/config": "^7.12.0",
+    "@basemaps/config-loader": "^7.12.0",
+    "@basemaps/geo": "^7.12.0",
+    "@basemaps/shared": "^7.12.0",
+    "@basemaps/tiler": "^7.12.0",
+    "@basemaps/tiler-sharp": "^7.12.0",
     "@linzjs/geojson": "^7.10.0",
     "@linzjs/lambda": "^4.0.0",
     "@mapbox/vector-tile": "^2.0.3",
@@ -50,11 +50,11 @@
     "bundle": "./bundle.sh"
   },
   "devDependencies": {
-    "@basemaps/attribution": "^7.11.0",
+    "@basemaps/attribution": "^7.12.0",
     "@chunkd/fs": "^11.2.0",
     "@types/aws-lambda": "^8.10.75",
     "@types/pixelmatch": "^5.0.0",
     "pretty-json-log": "^1.0.0"
   },
-  "gitHead": "99c1a7568dca77b55e44f2d446c00f092e14870d"
+  "gitHead": "9c1d78fe9e4cccb6309b761f17dc249681ce1769"
 }

package/src/index.ts

@@ -1,4 +1,4 @@
-import { FsaCache, FsaLog, LogConfig } from '@basemaps/shared';
+import { FsaCache, FsaLog, LogConfig, LogStorage } from '@basemaps/shared';
 import { LambdaHttpRequest, LambdaHttpResponse, lf } from '@linzjs/lambda';
 
 import { tileAttributionGet } from './routes/attribution.js';
@@ -6,6 +6,7 @@ import { configImageryGet, configTileSetGet } from './routes/config.js';
 import { fontGet, fontList } from './routes/fonts.js';
 import { healthGet } from './routes/health.js';
 import { imageryGet } from './routes/imagery.js';
+import { linkGet } from './routes/link.js';
 import { pingGet } from './routes/ping.js';
 import { previewIndexGet } from './routes/preview.index.js';
 import { tilePreviewGet } from './routes/preview.js';
@@ -33,13 +34,14 @@ function randomTrace(req: LambdaHttpRequest): void {
   const rand = Math.random();
   // 1% trace
   if (rand < 0.01) req.log.level = 'trace';
-  // 5% debug
-  else if (rand < 0.04) req.log.level = 'debug';
+  // 25% debug
+  else if (rand < 0.25) req.log.level = 'debug';
   // everything else info
   else req.log.level = 'info';
 }
 
 handler.router.hook('request', (req) => {
+  LogStorage.enterWith({ log: req.log });
   FsaLog.reset();
 
   randomTrace(req);
@@ -48,7 +50,8 @@ handler.router.hook('request', (req) => {
 });
 
 handler.router.hook('response', (req, res) => {
-  req.set('requestCount', FsaLog.requests.length);
+  req.set('fetchCount', FsaLog.count);
+  req.set('fetches', FsaLog.requests);
   req.set('cacheSize', FsaCache.size);
   // Force access-control-allow-origin to everything
   res.header('access-control-allow-origin', '*');
@@ -102,6 +105,9 @@ handler.router.get('/v1/preview/:tileSet/:tileMatrix/:z/:lon/:lat/:outputType',
 handler.router.get('/v1/@:location', previewIndexGet);
 handler.router.get('/@:location', previewIndexGet);
 
+// Link
+handler.router.get('/v1/link/:tileSet', linkGet);
+
 // Attribution
 handler.router.get('/v1/tiles/:tileSet/:tileMatrix/attribution.json', tileAttributionGet);
 handler.router.get('/v1/attribution/:tileSet/:tileMatrix/summary.json', tileAttributionGet);

package/src/routes/__tests__/link.test.ts

@@ -0,0 +1,114 @@
+import { strictEqual } from 'node:assert';
+import { afterEach, describe, it } from 'node:test';
+
+import { ConfigProviderMemory } from '@basemaps/config';
+import { Epsg } from '@basemaps/geo';
+
+import { FakeData, Imagery3857 } from '../../__tests__/config.data.js';
+import { mockRequest } from '../../__tests__/xyz.util.js';
+import { handler } from '../../index.js';
+import { ConfigLoader } from '../../util/config.loader.js';
+
+describe('/v1/link/:tileSet', () => {
+  const FakeTileSetName = 'tileset';
+  const config = new ConfigProviderMemory();
+
+  afterEach(() => {
+    config.objects.clear();
+  });
+
+  /**
+   * 3xx status responses
+   */
+
+  // tileset found, is raster type, has one layer, has '3857' entry, imagery found > 302 response
+  it('success: redirect to pre-zoomed imagery', async (t) => {
+    t.mock.method(ConfigLoader, 'getDefaultConfig', () => Promise.resolve(config));
+
+    config.put(FakeData.tileSetRaster(FakeTileSetName));
+    config.put(Imagery3857);
+
+    const req = mockRequest(`/v1/link/${FakeTileSetName}`);
+    const res = await handler.router.handle(req);
+
+    strictEqual(res.status, 302);
+    strictEqual(res.statusDescription, 'Redirect to pre-zoomed imagery');
+  });
+
+  /**
+   * 4xx status responses
+   */
+
+  // tileset not found > 404 response
+  it('failure: tileset not found', async (t) => {
+    t.mock.method(ConfigLoader, 'getDefaultConfig', () => Promise.resolve(config));
+
+    const req = mockRequest(`/v1/link/${FakeTileSetName}`);
+    const res = await handler.router.handle(req);
+
+    strictEqual(res.status, 404);
+    strictEqual(res.statusDescription, 'Tileset not found');
+  });
+
+  // tileset found, not raster type > 400 response
+  it('failure: tileset must be raster type', async (t) => {
+    t.mock.method(ConfigLoader, 'getDefaultConfig', () => Promise.resolve(config));
+
+    config.put(FakeData.tileSetVector(FakeTileSetName));
+
+    const req = mockRequest(`/v1/link/${FakeTileSetName}`);
+    const res = await handler.router.handle(req);
+
+    strictEqual(res.status, 400);
+    strictEqual(res.statusDescription, 'Tileset must be raster type');
+  });
+
+  // tileset found, is raster type, has more than one layer > 400 response
+  it('failure: too many layers', async (t) => {
+    t.mock.method(ConfigLoader, 'getDefaultConfig', () => Promise.resolve(config));
+
+    const tileSet = FakeData.tileSetRaster(FakeTileSetName);
+
+    // add another layer
+    tileSet.layers.push(tileSet.layers[0]);
+
+    config.put(tileSet);
+
+    const req = mockRequest(`/v1/link/${FakeTileSetName}`);
+    const res = await handler.router.handle(req);
+
+    strictEqual(res.status, 400);
+    strictEqual(res.statusDescription, 'Too many layers');
+  });
+
+  // tileset found, is raster type, has one layer, no '3857' entry > 400 response
+  it("failure: no imagery for '3857' projection", async (t) => {
+    t.mock.method(ConfigLoader, 'getDefaultConfig', () => Promise.resolve(config));
+
+    const tileSet = FakeData.tileSetRaster(FakeTileSetName);
+
+    // delete '3857' entry
+    delete tileSet.layers[0][Epsg.Google.code];
+
+    config.put(tileSet);
+
+    const req = mockRequest(`/v1/link/${FakeTileSetName}`);
+    const res = await handler.router.handle(req);
+
+    strictEqual(res.status, 400);
+    strictEqual(res.statusDescription, "No imagery for '3857' projection");
+  });
+
+  // tileset found, is raster type, has one layer, has '3857' entry, imagery not found > 400 response
+  it('failure: imagery not found', async (t) => {
+    t.mock.method(ConfigLoader, 'getDefaultConfig', () => Promise.resolve(config));
+
+    config.put(FakeData.tileSetRaster(FakeTileSetName));
+
+    const req = mockRequest(`/v1/link/${FakeTileSetName}`);
+    const res = await handler.router.handle(req);
+
+    strictEqual(res.status, 400);
+    strictEqual(res.statusDescription, 'Imagery not found');
+  });
+});

package/src/routes/__tests__/tile.style.json.attribution.test.ts

@@ -0,0 +1,224 @@
+import assert, { strictEqual } from 'node:assert';
+import { afterEach, before, describe, it } from 'node:test';
+
+import { copyright, createLicensorAttribution } from '@basemaps/attribution/build/utils.js';
+import { ConfigProviderMemory, StyleJson } from '@basemaps/config';
+import { StacProvider } from '@basemaps/geo';
+import { Env } from '@basemaps/shared';
+
+import { FakeData, Imagery3857 } from '../../__tests__/config.data.js';
+import { Api, mockRequest } from '../../__tests__/xyz.util.js';
+import { handler } from '../../index.js';
+import { ConfigLoader } from '../../util/config.loader.js';
+
+const defaultAttribution = `${copyright} LINZ`;
+
+describe('/v1/styles', () => {
+  const host = 'https://tiles.test';
+  const config = new ConfigProviderMemory();
+
+  const FakeTileSetName = 'tileset';
+  const FakeLicensor1: StacProvider = {
+    name: 'L1',
+    roles: ['licensor'],
+  };
+  const FakeLicensor2: StacProvider = {
+    name: 'L2',
+    roles: ['licensor'],
+  };
+
+  before(() => {
+    process.env[Env.PublicUrlBase] = host;
+  });
+  afterEach(() => {
+    config.objects.clear();
+  });
+
+  // tileset exists, imagery not found
+  it('default: imagery not found', async (t) => {
+    t.mock.method(ConfigLoader, 'getDefaultConfig', () => Promise.resolve(config));
+
+    // insert
+    config.put(FakeData.tileSetRaster(FakeTileSetName));
+
+    // request
+    const req = mockRequest(`/v1/styles/${FakeTileSetName}.json`, 'get', Api.header);
+    const res = await handler.router.handle(req);
+    strictEqual(res.status, 200);
+
+    // extract
+    const body = Buffer.from(res.body, 'base64').toString();
+    const json = JSON.parse(body) as StyleJson;
+
+    const source = Object.values(json.sources)[0];
+    assert(source != null);
+    assert(source.attribution != null);
+
+    // verify
+    strictEqual(source.attribution, defaultAttribution);
+  });
+
+  // tileset exists, imagery found, more than one layer
+  it('default: too many layers', async (t) => {
+    t.mock.method(ConfigLoader, 'getDefaultConfig', () => Promise.resolve(config));
+
+    // insert
+    const tileset = FakeData.tileSetRaster(FakeTileSetName);
+    assert(tileset.layers[0] != null);
+
+    tileset.layers.push(tileset.layers[0]);
+    assert(tileset.layers.length > 1);
+
+    config.put(tileset);
+    config.put(Imagery3857);
+
+    // request
+    const req = mockRequest(`/v1/styles/${FakeTileSetName}.json`, 'get', Api.header);
+    const res = await handler.router.handle(req);
+    strictEqual(res.status, 200);
+
+    // extract
+    const body = Buffer.from(res.body, 'base64').toString();
+    const json = JSON.parse(body) as StyleJson;
+
+    const source = Object.values(json.sources)[0];
+    assert(source != null);
+    assert(source.attribution != null);
+
+    // verify
+    strictEqual(source.attribution, defaultAttribution);
+  });
+
+  // tileset exists, imagery found, one layer, no providers
+  it('default: no providers', async (t) => {
+    t.mock.method(ConfigLoader, 'getDefaultConfig', () => Promise.resolve(config));
+
+    // insert
+    const tileset = FakeData.tileSetRaster(FakeTileSetName);
+    assert(tileset.layers[0] != null);
+    assert(tileset.layers.length === 1);
+
+    const imagery = Imagery3857;
+    assert(imagery.providers == null);
+
+    config.put(tileset);
+    config.put(imagery);
+
+    // request
+    const req = mockRequest(`/v1/styles/${FakeTileSetName}.json`, 'get', Api.header);
+    const res = await handler.router.handle(req);
+    strictEqual(res.status, 200);
+
+    // extract
+    const body = Buffer.from(res.body, 'base64').toString();
+    const json = JSON.parse(body) as StyleJson;
+
+    const source = Object.values(json.sources)[0];
+    assert(source != null);
+    assert(source.attribution != null);
+
+    // verify
+    strictEqual(source.attribution, defaultAttribution);
+  });
+
+  // tileset exists, imagery found, one layer, has providers, no licensors
+  it('default: no licensors', async (t) => {
+    t.mock.method(ConfigLoader, 'getDefaultConfig', () => Promise.resolve(config));
+
+    // insert
+    const tileset = FakeData.tileSetRaster(FakeTileSetName);
+    assert(tileset.layers[0] != null);
+    assert(tileset.layers.length === 1);
+
+    const imagery = Imagery3857;
+    imagery.providers = [];
+    assert(imagery.providers != null);
+
+    config.put(tileset);
+    config.put(imagery);
+
+    // request
+    const req = mockRequest(`/v1/styles/${FakeTileSetName}.json`, 'get', Api.header);
+    const res = await handler.router.handle(req);
+    strictEqual(res.status, 200);
+
+    // extract
+    const body = Buffer.from(res.body, 'base64').toString();
+    const json = JSON.parse(body) as StyleJson;
+
+    const source = Object.values(json.sources)[0];
+    assert(source != null);
+    assert(source.attribution != null);
+
+    // verify
+    strictEqual(source.attribution, defaultAttribution);
+  });
+
+  // tileset exists, imagery found, one layer, has providers, one licensor
+  it('custom: one licensor', async (t) => {
+    t.mock.method(ConfigLoader, 'getDefaultConfig', () => Promise.resolve(config));
+
+    // insert
+    const tileset = FakeData.tileSetRaster(FakeTileSetName);
+    assert(tileset.layers[0] != null);
+    assert(tileset.layers.length === 1);
+
+    const imagery = Imagery3857;
+    imagery.providers = [FakeLicensor1];
+    assert(imagery.providers != null);
+
+    config.put(tileset);
+    config.put(imagery);
+
+    // request
+    const req = mockRequest(`/v1/styles/${FakeTileSetName}.json`, 'get', Api.header);
+    const res = await handler.router.handle(req);
+    strictEqual(res.status, 200);
+
+    // extract
+    const body = Buffer.from(res.body, 'base64').toString();
+    const json = JSON.parse(body) as StyleJson;
+
+    const source = Object.values(json.sources)[0];
+    assert(source != null);
+    assert(source.attribution != null);
+
+    // verify
+    strictEqual(source.attribution, `${copyright} ${FakeLicensor1.name}`);
+    strictEqual(source.attribution, createLicensorAttribution([FakeLicensor1]));
+  });
+
+  // tileset exists, imagery found, one layer, has providers, two licensors
+  it('custom: two licensors', async (t) => {
+    t.mock.method(ConfigLoader, 'getDefaultConfig', () => Promise.resolve(config));
+
+    // insert
+    const tileset = FakeData.tileSetRaster(FakeTileSetName);
+    assert(tileset.layers[0] != null);
+    assert(tileset.layers.length === 1);
+
+    const imagery = Imagery3857;
+    imagery.providers = [FakeLicensor1, FakeLicensor2];
+    assert(imagery.providers != null);
+
+    config.put(tileset);
+    config.put(imagery);
+
+    // request
+    const req = mockRequest(`/v1/styles/${FakeTileSetName}.json`, 'get', Api.header);
+    const res = await handler.router.handle(req);
+    strictEqual(res.status, 200);
+
+    // extract
+    const body = Buffer.from(res.body, 'base64').toString();
+    const json = JSON.parse(body) as StyleJson;
+
+    const source = Object.values(json.sources)[0];
+    assert(source != null);
+    assert(source.attribution != null);
+
+    // verify
+    strictEqual(source.attribution, `${copyright} ${FakeLicensor1.name}, ${FakeLicensor2.name}`);
+    strictEqual(source.attribution, createLicensorAttribution([FakeLicensor1, FakeLicensor2]));
+  });
+});

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

@@ -2,7 +2,8 @@ import assert from 'node:assert';
 import { afterEach, before, beforeEach, describe, it } from 'node:test';
 
 import { ConfigProviderMemory, SourceRaster, StyleJson } from '@basemaps/config';
-import { Terrain } from '@basemaps/config/src/config/vector.style.js';
+import { DefaultExaggeration, Terrain } from '@basemaps/config/build/config/vector.style.js';
+import { Nztm2000QuadTms } from '@basemaps/geo';
 import { Env } from '@basemaps/shared';
 import { createSandbox } from 'sinon';
 
@@ -441,7 +442,7 @@ describe('/v1/styles', () => {
           },
         ],
         terrain: {
-          exaggeration: 1.1,
+          exaggeration: DefaultExaggeration[Nztm2000QuadTms.identifier],
         },
       },
     };

package/src/routes/attribution.ts

@@ -1,9 +1,11 @@
-import { ConfigProvider, ConfigTileSet, getAllImagery, TileSetType } from '@basemaps/config';
+import { createLicensorAttribution } from '@basemaps/attribution/build/utils.js';
+import { BasemapsConfigProvider, ConfigProvider, ConfigTileSet, getAllImagery, TileSetType } from '@basemaps/config';
 import {
   AttributionCollection,
   AttributionItem,
   AttributionStac,
   Bounds,
+  Epsg,
   GoogleTms,
   NamedBounds,
   Projection,
@@ -93,10 +95,11 @@ async function tileSetAttribution(
 
   const config = await ConfigLoader.load(req);
   const imagery = await getAllImagery(config, tileSet.layers, [tileMatrix.projection]);
-
   const host = await config.Provider.get(config.Provider.id('linz'));
 
-  for (const layer of tileSet.layers) {
+  for (let i = 0; i < tileSet.layers.length; i++) {
+    const layer = tileSet.layers[i];
+
     const imgId = layer[proj.epsg.code];
     if (imgId == null) continue;
 
@@ -138,11 +141,12 @@ async function tileSetAttribution(
 
     const zoomMin = TileMatrixSet.convertZoomLevel(layer.minZoom ? layer.minZoom : 0, GoogleTms, tileMatrix, true);
     const zoomMax = TileMatrixSet.convertZoomLevel(layer.maxZoom ? layer.maxZoom : 32, GoogleTms, tileMatrix, true);
+
     cols.push({
       stac_version: Stac.Version,
       license: Stac.License,
       id: im.id,
-      providers: getHost(host),
+      providers: im.providers ?? getHost(host),
       title,
       description: 'No description',
       extent,
@@ -150,10 +154,11 @@ async function tileSetAttribution(
       summaries: {
         'linz:category': im.category,
         'linz:zoom': { min: zoomMin, max: zoomMax },
-        'linz:priority': [1000 + tileSet.layers.indexOf(layer)],
+        'linz:priority': [1000 + i],
       },
     });
   }
+
   return {
     id: tileSet.id,
     type: 'FeatureCollection',
@@ -205,3 +210,43 @@ export async function tileAttributionGet(req: LambdaHttpRequest<TileAttributionG
   response.json(attributions);
   return response;
 }
+
+/**
+ * Construct a licensor attribution for a given tileSet.
+ *
+ * @param provider The BasemapsConfigProvider object.
+ * @param tileSet The tileset from which to build the attribution.
+ * @param projection The projection to consider.
+ *
+ * @returns A default attribution, if the tileset has more than one layer or no such imagery for the given projection exists.
+ * Otherwise, a copyright string comprising the names of the tileset's licensors.
+ *
+ * @example
+ * "CC BY 4.0 LINZ"
+ *
+ * @example
+ * "CC BY 4.0 Nelson City Council, Tasman District Council, Waka Kotahi"
+ */
+export async function createTileSetAttribution(
+  provider: BasemapsConfigProvider,
+  tileSet: ConfigTileSet,
+  projection: Epsg,
+): Promise<string> {
+  // ensure the tileset has exactly one layer
+  if (tileSet.layers.length > 1 || tileSet.layers[0] == null) {
+    return createLicensorAttribution();
+  }
+
+  // ensure imagery exist for the given projection
+  const imgId = tileSet.layers[0][projection.code];
+  if (imgId == null) return '';
+
+  // attempt to load the imagery
+  const imagery = await provider.Imagery.get(imgId);
+  if (imagery?.providers == null) {
+    return createLicensorAttribution();
+  }
+
+  // return a licensor attribution string
+  return createLicensorAttribution(imagery.providers);
+}

package/src/routes/link.ts

@@ -0,0 +1,55 @@
+import { TileSetType } from '@basemaps/config';
+import { Epsg } from '@basemaps/geo';
+import { getPreviewUrl } from '@basemaps/shared';
+import { LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+
+import { ConfigLoader } from '../util/config.loader.js';
+
+export interface LinkGet {
+  Params: {
+    tileSet: string;
+  };
+}
+
+/**
+ * Redirect the client to a Basemaps URL that is already zoomed to the extent of the tileset's imagery.
+ *
+ * /v1/link/:tileSet
+ *
+ * @example
+ * '/v1/link/ashburton-2023-0.1m'
+ *
+ * @returns on success, 302 redirect response. on failure, 4xx status code response.
+ */
+export async function linkGet(req: LambdaHttpRequest<LinkGet>): Promise<LambdaHttpResponse> {
+  const config = await ConfigLoader.load(req);
+
+  // get tileset
+
+  req.timer.start('tileset:load');
+  const tileSet = await config.TileSet.get(req.params.tileSet);
+  req.timer.end('tileset:load');
+
+  if (tileSet == null) return new LambdaHttpResponse(404, 'Tileset not found');
+
+  if (tileSet.type !== TileSetType.Raster) return new LambdaHttpResponse(400, 'Tileset must be raster type');
+
+  // TODO: add support for 'aerial' and 'elevation' multi-layer tilesets
+  if (tileSet.layers.length !== 1) return new LambdaHttpResponse(400, 'Too many layers');
+
+  // get imagery
+
+  const imageryId = tileSet.layers[0][Epsg.Google.code];
+  if (imageryId === undefined) return new LambdaHttpResponse(400, "No imagery for '3857' projection");
+
+  const imagery = await config.Imagery.get(imageryId);
+  if (imagery == null) return new LambdaHttpResponse(400, 'Imagery not found');
+
+  // do redirect
+
+  const url = getPreviewUrl({ imagery });
+
+  return new LambdaHttpResponse(302, 'Redirect to pre-zoomed imagery', {
+    location: `/${url.slug}?i=${url.name}`,
+  });
+}

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

@@ -19,6 +19,7 @@ import { Etag } from '../util/etag.js';
 import { convertStyleToNztmStyle } from '../util/nztm.style.js';
 import { NotFound, NotModified } from '../util/response.js';
 import { Validate } from '../util/validate.js';
+import { createTileSetAttribution } from './attribution.js';
 
 /**
  * Convert relative URL into a full hostname URL, converting {tileMatrix} into the provided tileMatrix
@@ -89,7 +90,7 @@ export interface StyleConfig {
 /**
  * Turn on the terrain setting in the style json
  */
-function setStyleTerrain(style: StyleJson, terrain: string, tileMatrix: TileMatrixSet): void {
+export function setStyleTerrain(style: StyleJson, terrain: string, tileMatrix: TileMatrixSet): void {
   const source = Object.keys(style.sources).find((s) => s === terrain);
   if (source == null) throw new LambdaHttpResponse(400, `Terrain: ${terrain} does not exists in the style source.`);
   style.terrain = {
@@ -153,12 +154,13 @@ async function ensureTerrain(
  * Generate a StyleJSON from a tileset
  * @returns
  */
-export function tileSetToStyle(
+export async function tileSetToStyle(
   req: LambdaHttpRequest<StyleGet>,
+  config: BasemapsConfigProvider,
   tileSet: ConfigTileSetRaster,
   tileMatrix: TileMatrixSet,
   apiKey: string,
-): StyleJson {
+): Promise<StyleJson> {
   // If the style has outputs defined it has a different process for generating the stylejson
   if (tileSet.outputs) return tileSetOutputToStyle(req, tileSet, tileMatrix, apiKey);
 
@@ -175,12 +177,21 @@ export function tileSetToStyle(
     (Env.get(Env.PublicUrlBase) ?? '') +
     `/v1/tiles/${tileSet.name}/${tileMatrix.identifier}/{z}/{x}/{y}.${tileFormat}${query}`;
 
+  const attribution = await createTileSetAttribution(config, tileSet, tileMatrix.projection);
+
   const styleId = `basemaps-${tileSet.name}`;
   return {
     id: ConfigId.prefix(ConfigPrefix.Style, tileSet.name),
     name: tileSet.name,
     version: 8,
-    sources: { [styleId]: { type: 'raster', tiles: [tileUrl], tileSize: 256 } },
+    sources: {
+      [styleId]: {
+        type: 'raster',
+        tiles: [tileUrl],
+        tileSize: 256,
+        attribution,
+      },
+    },
     layers: [{ id: styleId, type: 'raster', source: styleId }],
   };
 }
@@ -248,7 +259,7 @@ async function generateStyleFromTileSet(
     throw new LambdaHttpResponse(400, 'Only raster tile sets can generate style JSON');
   }
   if (tileSet.outputs) return tileSetOutputToStyle(req, tileSet, tileMatrix, apiKey);
-  else return tileSetToStyle(req, tileSet, tileMatrix, apiKey);
+  return tileSetToStyle(req, config, tileSet, tileMatrix, apiKey);
 }
 
 export interface StyleGet {