@basemaps/lambda-tiler 7.0.0 → 7.1.0

package/src/routes/health.ts

@@ -1,11 +1,11 @@
+import * as fs from 'node:fs';
+
 import { ConfigTileSetRaster } from '@basemaps/config';
-import { GoogleTms, ImageFormat, Nztm2000QuadTms } from '@basemaps/geo';
+import { GoogleTms, Nztm2000QuadTms } from '@basemaps/geo';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
-import * as fs from 'fs';
-import * as path from 'path';
 import PixelMatch from 'pixelmatch';
 import Sharp from 'sharp';
-import url from 'url';
+
 import { ConfigLoader } from '../util/config.loader.js';
 import { TileXyz } from '../util/validate.js';
 import { TileXyzRaster } from './tile.xyz.raster.js';
@@ -15,8 +15,8 @@ interface TestTile extends TileXyz {
 }
 
 export const TestTiles: TestTile[] = [
-  { tileSet: 'health', tileMatrix: GoogleTms, tileType: ImageFormat.Png, tile: { x: 252, y: 156, z: 8 } },
-  { tileSet: 'health', tileMatrix: Nztm2000QuadTms, tileType: ImageFormat.Png, tile: { x: 30, y: 33, z: 6 } },
+  { tileSet: 'health', tileMatrix: GoogleTms, tileType: 'png', tile: { x: 252, y: 156, z: 8 } },
+  { tileSet: 'health', tileMatrix: Nztm2000QuadTms, tileType: 'png', tile: { x: 30, y: 33, z: 6 } },
 ];
 const TileSize = 256;
 
@@ -26,13 +26,7 @@ export async function getTestBuffer(test: TestTile): Promise<Buffer> {
 
   const expectedFile = `static/expected_tile_${test.tileMatrix.identifier}_${tile.x}_${tile.y}_z${tile.z}.${test.tileType}`;
   // Initiate test img buffer if not defined
-  try {
-    return await fs.promises.readFile(expectedFile);
-  } catch (e: any) {
-    if (e.code !== 'ENOENT') throw e;
-    const otherFile = path.join(path.dirname(url.fileURLToPath(import.meta.url)), '..', '..', expectedFile);
-    return await fs.promises.readFile(otherFile);
-  }
+  return await fs.promises.readFile(expectedFile);
 }
 
 export async function updateExpectedTile(test: TestTile, newTileData: Buffer, difference: Buffer): Promise<void> {

package/src/routes/imagery.ts

@@ -2,6 +2,7 @@ import { fsa } from '@basemaps/shared';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import { promisify } from 'util';
 import { gzip } from 'zlib';
+
 import { ConfigLoader } from '../util/config.loader.js';
 import { isGzip } from '../util/cotar.serve.js';
 import { Etag } from '../util/etag.js';
@@ -38,7 +39,7 @@ export async function imageryGet(req: LambdaHttpRequest<ImageryGet>): Promise<La
   const imagery = await config.Imagery.get(config.Imagery.id(req.params.imageryId));
   if (imagery == null) return NotFound();
 
-  const targetPath = fsa.join(imagery.uri, requestedFile);
+  const targetPath = new URL(requestedFile, fsa.toUrl(imagery.uri));
 
   try {
     const buf = await fsa.read(targetPath);

package/src/routes/ping.ts

@@ -1,4 +1,4 @@
-import { LambdaHttpResponse, HttpHeader } from '@linzjs/lambda';
+import { HttpHeader, LambdaHttpResponse } from '@linzjs/lambda';
 
 const OkResponse = new LambdaHttpResponse(200, 'ok');
 OkResponse.header(HttpHeader.CacheControl, 'no-store');

package/src/routes/preview.index.ts

@@ -1,10 +1,12 @@
+import { promisify } from 'node:util';
+import { gunzip } from 'node:zlib';
+
 import { GoogleTms, LocationUrl, LonLatZoom, TileMatrixSets } from '@basemaps/geo';
+import { Env, fsa, getPreviewQuery } from '@basemaps/shared';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+
 import { ConfigLoader } from '../util/config.loader.js';
-import { Env, fsa } from '@basemaps/shared';
 import { isGzip } from '../util/cotar.serve.js';
-import { gunzip } from 'node:zlib';
-import { promisify } from 'node:util';
 import { Etag } from '../util/etag.js';
 
 const gunzipP = promisify(gunzip);
@@ -43,8 +45,10 @@ export async function loadAndServeIndexHtml(
     });
   }
 
+  const staticUrl = fsa.toUrl(staticLocation);
+
   try {
-    let indexHtml = await fsa.read(fsa.join(staticLocation, 'index.html'));
+    let indexHtml = await fsa.read(new URL('index.html', staticUrl));
     if (isGzip(indexHtml)) indexHtml = await gunzipP(indexHtml);
 
     const res = new LambdaHttpResponse(200, 'ok');
@@ -100,7 +104,7 @@ export async function previewIndexGet(req: LambdaHttpRequest<PreviewIndexGet>):
   const shortLocation = [short.zoom, short.lon, short.lat].join('/');
 
   const cfg = ConfigLoader.extract(req);
-  const queryParams = cfg == null ? '' : `?config=${cfg}`;
+  const queryParams = getPreviewQuery({ config: cfg, pipeline: query.pipeline ?? tileSet.outputs?.[0]?.name });
 
   // Include tile matrix name eg "[NZTM2000Quad]" in the title if its not WebMercatorQuad
   const tileMatrixId = tileMatrix.identifier === GoogleTms.identifier ? '' : ` [${tileMatrix.identifier}]`;

package/src/routes/preview.ts

@@ -1,19 +1,21 @@
-import { ConfigTileSetRaster } from '@basemaps/config';
-import { Bounds, ImageFormat, LatLon, Projection, TileMatrixSet } from '@basemaps/geo';
-import { CompositionTiff, Tiler } from '@basemaps/tiler';
+import { ConfigTileSetRaster, ConfigTileSetRasterOutput } from '@basemaps/config';
+import { Bounds, LatLon, Projection, TileMatrixSet } from '@basemaps/geo';
+import { CompositionTiff, TileMakerContext, Tiler } from '@basemaps/tiler';
 import { SharpOverlay, TileMakerSharp } from '@basemaps/tiler-sharp';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import sharp from 'sharp';
+
 import { ConfigLoader } from '../util/config.loader.js';
 import { Etag } from '../util/etag.js';
 import { NotModified } from '../util/response.js';
 import { Validate } from '../util/validate.js';
-import { DefaultResizeKernel, TileXyzRaster, isArchiveTiff } from './tile.xyz.raster.js';
-import sharp from 'sharp';
+import { DefaultBackground, DefaultResizeKernel, isArchiveTiff, TileXyzRaster } from './tile.xyz.raster.js';
 
 export interface PreviewGet {
   Params: {
     tileSet: string;
     tileMatrix: string;
+    outputType?: string;
     lat: string;
     lon: string;
     z: string;
@@ -23,7 +25,6 @@ export interface PreviewGet {
 const PreviewSize = { width: 1200, height: 630 };
 const TilerSharp = new TileMakerSharp(PreviewSize.width, PreviewSize.height);
 
-const OutputFormat = ImageFormat.Webp;
 /** Slightly grey color for the checker background */
 const PreviewBackgroundFillColor = 0xef;
 /** Make th e checkered background 30x30px */
@@ -33,6 +34,7 @@ const PreviewBackgroundSizePx = 30;
  * Serve a preview of a imagery set
  *
  * /v1/preview/:tileSet/:tileMatrixSet/:z/:lon/:lat
+ * /v1/preview/:tileSet/:tileMatrixSet/:z/:lon/:lat/:outputType
  *
  * @example
  * Raster Tile `/v1/preview/aerial/WebMercatorQuad/12/177.3998405/-39.0852555`
@@ -46,8 +48,6 @@ export async function tilePreviewGet(req: LambdaHttpRequest<PreviewGet>): Promis
   req.set('projection', tileMatrix.projection.code);
 
   // TODO we should detect the format based off the "Accept" header and maybe default back to webp
-  req.set('extension', OutputFormat);
-
   const location = Validate.getLocation(req.params.lon, req.params.lat);
   if (location == null) return new LambdaHttpResponse(404, 'Preview location not found');
   req.set('location', location);
@@ -64,7 +64,23 @@ export async function tilePreviewGet(req: LambdaHttpRequest<PreviewGet>): Promis
   // Only raster previews are supported
   if (tileSet.type !== 'raster') return new LambdaHttpResponse(404, 'Preview invalid tile set type');
 
-  return renderPreview(req, { tileSet, tileMatrix, location, outputFormat: OutputFormat, z });
+  const pipeline = req.query.get('pipeline');
+
+  // Use the prefered output format from the pipeline if its defined
+  let defaultFormat = 'webp';
+  if (pipeline) {
+    const output = tileSet.outputs?.find((f) => f.name === pipeline);
+    defaultFormat = output?.format?.[0] ?? defaultFormat;
+  }
+
+  const outputFormat = req.params.outputType ?? defaultFormat;
+
+  const tileOutput = Validate.pipeline(tileSet, outputFormat, req.query.get('pipeline'));
+  if (tileOutput == null) return new LambdaHttpResponse(404, `Output format: ${outputFormat} not found`);
+  req.set('extension', outputFormat);
+  req.set('pipeline', tileOutput.name ?? 'rgba');
+
+  return renderPreview(req, { tileSet, tileMatrix, location, output: tileOutput, z });
 }
 
 interface PreviewRenderContext {
@@ -74,8 +90,8 @@ interface PreviewRenderContext {
   tileMatrix: TileMatrixSet;
   /** Center point of the preview */
   location: LatLon;
-  /** Iamge format to render the preview as */
-  outputFormat: ImageFormat;
+  /** Image format to render the preview as */
+  output: ConfigTileSetRasterOutput;
   /** Zom level to be use, must be a integer */
   z: number;
 }
@@ -133,10 +149,23 @@ export async function renderPreview(req: LambdaHttpRequest, ctx: PreviewRenderCo
     compositions.push(...result);
   }
 
+  const tileOutput = ctx.output;
+  const tileContext: TileMakerContext = {
+    layers: compositions,
+    pipeline: tileOutput.pipeline,
+    format: tileOutput.format?.[0] ?? 'webp', // default to the first output format if defined or webp
+    background: tileOutput.background ?? ctx.tileSet.background ?? DefaultBackground,
+    resizeKernel: tileOutput.resizeKernel ?? ctx.tileSet.resizeKernel ?? DefaultResizeKernel,
+    log: req.log,
+  };
+
   // Load all the tiff tiles and resize/them into the correct locations
   req.timer.start('compose:overlay');
   const overlays = (await Promise.all(
-    compositions.map((comp) => TilerSharp.composeTileTiff(comp, DefaultResizeKernel)),
+    compositions.map((comp) => {
+      if (tileContext.pipeline) return TilerSharp.composeTilePipeline(comp, tileContext);
+      return TilerSharp.composeTileTiff(comp, tileContext.resizeKernel);
+    }),
   ).then((items) => items.filter((f) => f != null))) as SharpOverlay[];
   req.timer.end('compose:overlay');
 
@@ -145,7 +174,7 @@ export async function renderPreview(req: LambdaHttpRequest, ctx: PreviewRenderCo
   img.composite(overlays);
 
   req.timer.start('compose:compress');
-  const buf = await TilerSharp.toImage(ctx.outputFormat, img);
+  const buf = await TilerSharp.toImage(tileContext.format, img, tileContext.lossless);
   req.timer.end('compose:compress');
 
   req.set('layersUsed', overlays.length);
@@ -153,10 +182,10 @@ export async function renderPreview(req: LambdaHttpRequest, ctx: PreviewRenderCo
   const response = new LambdaHttpResponse(200, 'ok');
   response.header(HttpHeader.ETag, cacheKey);
   response.header(HttpHeader.CacheControl, 'public, max-age=604800, stale-while-revalidate=86400');
-  response.buffer(buf, 'image/' + ctx.outputFormat);
+  response.buffer(buf, 'image/' + tileContext.format);
 
   const shortLocation = [ctx.location.lon.toFixed(7), ctx.location.lat.toFixed(7)].join('_');
-  const suggestedFileName = `preview_${ctx.tileSet.name}_z${ctx.z}_${shortLocation}.${ctx.outputFormat}`;
+  const suggestedFileName = `preview_${ctx.tileSet.name}_z${ctx.z}_${shortLocation}-${ctx.output.name}.${tileContext.format}`;
   response.header('Content-Disposition', `inline; filename=\"${suggestedFileName}\"`);
 
   return response;

package/src/routes/sprites.ts

@@ -1,8 +1,8 @@
-import { fsa } from '@chunkd/fs';
-import path from 'path';
 import { LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
-import { NotFound } from '../util/response.js';
+import path from 'path';
+
 import { assetProvider } from '../util/assets.provider.js';
+import { NotFound } from '../util/response.js';
 
 interface SpriteGet {
   Params: {
@@ -19,6 +19,5 @@ export async function spriteGet(req: LambdaHttpRequest<SpriteGet>): Promise<Lamb
   const mimeType = Extensions.get(extension);
   if (mimeType == null) return NotFound();
 
-  const targetFile = fsa.join('sprites', req.params.spriteName);
-  return assetProvider.serve(req, targetFile, mimeType);
+  return assetProvider.serve(req, `sprites/${req.params.spriteName}`, mimeType);
 }

package/src/routes/tile.json.ts

@@ -1,6 +1,8 @@
-import { GoogleTms, TileJson, TileMatrixSet } from '@basemaps/geo';
+import { ConfigTileSet, TileSetType } from '@basemaps/config';
+import { GoogleTms, OutputFormat, TileJson, TileMatrixSet } from '@basemaps/geo';
 import { Env, toQueryString } from '@basemaps/shared';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+
 import { ConfigLoader } from '../util/config.loader.js';
 import { getFilters } from '../util/filter.js';
 import { NotFound } from '../util/response.js';
@@ -13,6 +15,11 @@ export interface TileJsonGet {
   };
 }
 
+function defaultOutputFormat(tileSet: ConfigTileSet): OutputFormat[] {
+  if (tileSet.type === TileSetType.Vector) return ['pbf'];
+  return ['webp'];
+}
+
 export async function tileJsonGet(req: LambdaHttpRequest<TileJsonGet>): Promise<LambdaHttpResponse> {
   const tileMatrix = Validate.getTileMatrixSet(req.params.tileMatrix);
   if (tileMatrix == null) return NotFound();
@@ -26,7 +33,7 @@ export async function tileJsonGet(req: LambdaHttpRequest<TileJsonGet>): Promise<
   req.timer.end('tileset:load');
   if (tileSet == null) return NotFound();
 
-  const format = Validate.getRequestedFormats(req) ?? [tileSet.format];
+  const format: OutputFormat[] = Validate.getRequestedFormats(req) ?? defaultOutputFormat(tileSet);
 
   const host = Env.get(Env.PublicUrlBase) ?? '';
 

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

@@ -1,14 +1,14 @@
 import { ConfigTileSetRaster, Layer, Sources, StyleJson, TileSetType } from '@basemaps/config';
+import { GoogleTms, TileMatrixSets } from '@basemaps/geo';
 import { Env, toQueryString } from '@basemaps/shared';
-import { fsa } from '@chunkd/fs';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import { URL } from 'url';
-import { NotFound, NotModified } from '../util/response.js';
-import { Validate } from '../util/validate.js';
-import { Etag } from '../util/etag.js';
+
 import { ConfigLoader } from '../util/config.loader.js';
-import { GoogleTms, ImageFormat, TileMatrixSets } from '@basemaps/geo';
+import { Etag } from '../util/etag.js';
 import { getFilters } from '../util/filter.js';
+import { NotFound, NotModified } from '../util/response.js';
+import { Validate } from '../util/validate.js';
 
 /**
  * Convert relative URLS into a full hostname url
@@ -20,7 +20,7 @@ export function convertRelativeUrl(url?: string, apiKey?: string, config?: strin
   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));
+  const fullUrl = new URL(url, host);
   if (apiKey) fullUrl.searchParams.set('api', apiKey);
   if (config) fullUrl.searchParams.set('config', config);
   return fullUrl.toString().replace(/%7B/g, '{').replace(/%7D/g, '}');
@@ -70,16 +70,19 @@ export async function tileSetToStyle(
 ): Promise<LambdaHttpResponse> {
   const tileMatrix = TileMatrixSets.find(req.query.get('tileMatrix') ?? GoogleTms.identifier);
   if (tileMatrix == null) return new LambdaHttpResponse(400, 'Invalid tile matrix');
-  const [tileFormat] = Validate.getRequestedFormats(req) ?? [ImageFormat.Webp];
+  const [tileFormat] = Validate.getRequestedFormats(req) ?? ['webp'];
   if (tileFormat == null) return new LambdaHttpResponse(400, 'Invalid image format');
 
+  const pipeline = Validate.pipeline(tileSet, tileFormat, req.query.get('pipeline'));
+  const pipelineName = pipeline?.name === 'rgba' ? undefined : pipeline?.name;
+
   const configLocation = ConfigLoader.extract(req);
-  const query = toQueryString({ config: configLocation, api: apiKey, ...getFilters(req) });
+  const query = toQueryString({ config: configLocation, api: apiKey, ...getFilters(req), pipeline: pipelineName });
+
+  const tileUrl =
+    (Env.get(Env.PublicUrlBase) ?? '') +
+    `/v1/tiles/${tileSet.name}/${tileMatrix.identifier}/{z}/{x}/{y}.${tileFormat}${query}`;
 
-  const tileUrl = fsa.join(
-    Env.get(Env.PublicUrlBase) ?? '',
-    `/v1/tiles/${tileSet.name}/${tileMatrix.identifier}/{z}/{x}/{y}.${tileFormat}${query}`,
-  );
   const styleId = `basemaps-${tileSet.name}`;
   const style = {
     version: 8,
@@ -99,6 +102,78 @@ export async function tileSetToStyle(
   return response;
 }
 
+export async function tileSetOutputToStyle(
+  req: LambdaHttpRequest<StyleGet>,
+  tileSet: ConfigTileSetRaster,
+  apiKey: string,
+): Promise<LambdaHttpResponse> {
+  const tileMatrix = TileMatrixSets.find(req.query.get('tileMatrix') ?? GoogleTms.identifier);
+  if (tileMatrix == null) return new LambdaHttpResponse(400, 'Invalid tile matrix');
+
+  const configLocation = ConfigLoader.extract(req);
+  const query = toQueryString({ config: configLocation, api: apiKey, ...getFilters(req) });
+
+  const styleId = `basemaps-${tileSet.name}`;
+  const sources: Sources = {};
+  const layers: Layer[] = [];
+
+  if (tileSet.outputs) {
+    //for loop output.
+    for (const output of tileSet.outputs) {
+      const format = output.format?.[0] ?? 'webp';
+      const urlBase = Env.get(Env.PublicUrlBase) ?? '';
+      const tileUrl = `${urlBase}/v1/tiles/${tileSet.name}/${tileMatrix.identifier}/{z}/{x}/{y}.${format}${query}`;
+
+      if (output.name === 'terrain-rgb') {
+        // Add both raster source and dem raster source for terrain-rgb output
+        sources[`${styleId}-${output.name}`] = {
+          type: 'raster',
+          tiles: [tileUrl + `&pipeline=${output.name}`],
+          tileSize: 256,
+        };
+        sources[`${styleId}-${output.name}-dem`] = {
+          type: 'raster-dem',
+          tiles: [tileUrl + `&pipeline=${output.name}`],
+          tileSize: 256,
+        };
+      } else {
+        // Add raster source other outputs
+        sources[`${styleId}-${output.name}`] = {
+          type: 'raster',
+          tiles: [tileUrl + `&pipeline=${output.name}`],
+          tileSize: 256,
+        };
+      }
+    }
+  }
+
+  // Add first raster source as default layer
+  for (const source of Object.keys(sources)) {
+    if (sources[source].type === 'raster') {
+      layers.push({
+        id: styleId,
+        type: 'raster',
+        source,
+      });
+      break;
+    }
+  }
+
+  const style = { version: 8, sources, layers };
+
+  const data = Buffer.from(JSON.stringify(style));
+
+  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;
+}
+
 export async function styleJsonGet(req: LambdaHttpRequest<StyleGet>): Promise<LambdaHttpResponse> {
   const apiKey = Validate.apiKey(req);
   const styleName = req.params.styleName;
@@ -114,7 +189,8 @@ export async function styleJsonGet(req: LambdaHttpRequest<StyleGet>): Promise<La
     const tileSet = await config.TileSet.get(config.TileSet.id(styleName));
     if (tileSet == null) return NotFound();
     if (tileSet.type !== TileSetType.Raster) return NotFound();
-    return tileSetToStyle(req, tileSet, apiKey);
+    if (tileSet.outputs) return tileSetOutputToStyle(req, tileSet, apiKey);
+    else return tileSetToStyle(req, tileSet, apiKey);
   }
 
   // Prepare sources and add linz source

package/src/routes/tile.wmts.ts

@@ -3,12 +3,13 @@ import { GoogleTms, Nztm2000QuadTms, TileMatrixSet } from '@basemaps/geo';
 import { Env } from '@basemaps/shared';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import { createHash } from 'crypto';
+
+import { ConfigLoader } from '../util/config.loader.js';
+import { Etag } from '../util/etag.js';
+import { filterLayers, getFilters } from '../util/filter.js';
 import { NotFound, NotModified } from '../util/response.js';
 import { Validate } from '../util/validate.js';
 import { WmtsCapabilities } from '../wmts.capability.js';
-import { Etag } from '../util/etag.js';
-import { ConfigLoader } from '../util/config.loader.js';
-import { filterLayers, getFilters } from '../util/filter.js';
 
 export interface WmtsCapabilitiesGet {
   Params: {

package/src/routes/tile.xyz.raster.ts

@@ -1,18 +1,17 @@
-import { getAllImagery, ConfigTileSetRaster } from '@basemaps/config';
-import { Bounds, Epsg, TileMatrixSet, TileMatrixSets, VectorFormat } from '@basemaps/geo';
-import { Env, fsa } from '@basemaps/shared';
+import { ConfigTileSetRaster, getAllImagery } from '@basemaps/config';
+import { Bounds, Epsg, ImageFormat, TileMatrixSet, TileMatrixSets } from '@basemaps/geo';
+import { Cotar, Env, stringToUrlFolder, Tiff } from '@basemaps/shared';
 import { Tiler } from '@basemaps/tiler';
 import { TileMakerSharp } from '@basemaps/tiler-sharp';
-import { CogTiff } from '@cogeotiff/core';
-import { Cotar } from '@cotar/core';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import pLimit from 'p-limit';
+
 import { ConfigLoader } from '../util/config.loader.js';
 import { Etag } from '../util/etag.js';
 import { filterLayers } from '../util/filter.js';
 import { NotFound, NotModified } from '../util/response.js';
 import { CoSources } from '../util/source.cache.js';
-import { TileXyz } from '../util/validate.js';
+import { TileXyz, Validate } from '../util/validate.js';
 
 const LoadingQueue = pLimit(Env.getNumber(Env.TiffConcurrency, 25));
 
@@ -22,13 +21,13 @@ export function getTiffName(name: string): string {
   return `${name}.tiff`;
 }
 
-export type CloudArchive = CogTiff | Cotar;
+export type CloudArchive = Tiff | Cotar;
 
 /** Check to see if a cloud archive is a Tiff or a Cotar */
-export function isArchiveTiff(x: CloudArchive): x is CogTiff {
-  if (x instanceof CogTiff) return true;
-  if (x.source.uri.endsWith('.tiff')) return true;
-  if (x.source.uri.endsWith('.tif')) return true;
+export function isArchiveTiff(x: CloudArchive): x is Tiff {
+  if (x instanceof Tiff) return true;
+  if (x.source.url.pathname.endsWith('.tiff')) return true;
+  if (x.source.url.pathname.endsWith('.tif')) return true;
   return false;
 }
 
@@ -45,12 +44,12 @@ export const TileXyzRaster = {
     bounds: Bounds,
     zoom: number,
     ignoreOverview = false,
-  ): Promise<string[]> {
+  ): Promise<URL[]> {
     const config = await ConfigLoader.load(req);
     const imagery = await getAllImagery(config, tileSet.layers, [tileMatrix.projection]);
     const filteredLayers = filterLayers(req, tileSet.layers);
 
-    const output: string[] = [];
+    const output: URL[] = [];
 
     // All zoom level config is stored as Google zoom levels
     const filterZoom = TileMatrixSet.convertZoomLevel(zoom, tileMatrix, TileMatrixSets.get(Epsg.Google));
@@ -69,6 +68,7 @@ export const TileXyzRaster = {
       }
       if (!bounds.intersects(Bounds.fromJson(img.bounds))) continue;
 
+      const imgUrl = stringToUrlFolder(img.uri);
       for (const c of img.files) {
         if (!bounds.intersects(Bounds.fromJson(c))) continue;
 
@@ -80,23 +80,23 @@ export const TileXyzRaster = {
           img.overviews.minZoom <= filterZoom &&
           ignoreOverview !== true
         ) {
-          output.push(fsa.join(img.uri, img.overviews.path));
+          output.push(new URL(img.overviews.path, imgUrl));
           break;
         }
 
-        const tiffPath = fsa.join(img.uri, getTiffName(c.name));
+        const tiffPath = new URL(getTiffName(c.name), imgUrl);
         output.push(tiffPath);
       }
     }
     return output;
   },
 
-  async loadAssets(req: LambdaHttpRequest, assets: string[]): Promise<CloudArchive[]> {
+  async loadAssets(req: LambdaHttpRequest, assets: URL[]): Promise<CloudArchive[]> {
     const toLoad: Promise<CloudArchive | null>[] = [];
     for (const assetPath of assets) {
       toLoad.push(
         LoadingQueue((): Promise<CloudArchive | null> => {
-          if (assetPath.endsWith('.tar.co')) {
+          if (assetPath.pathname.endsWith('.tar.co')) {
             return CoSources.getCotar(assetPath).catch((error) => {
               req.log.warn({ error, tiff: assetPath }, 'Load:Cotar:Failed');
               return null;
@@ -113,13 +113,15 @@ export const TileXyzRaster = {
     return (await Promise.all(toLoad)).filter((f) => f != null) as CloudArchive[];
   },
 
-  async getAssetsForTile(req: LambdaHttpRequest, tileSet: ConfigTileSetRaster, xyz: TileXyz): Promise<string[]> {
+  async getAssetsForTile(req: LambdaHttpRequest, tileSet: ConfigTileSetRaster, xyz: TileXyz): Promise<URL[]> {
     const tileBounds = xyz.tileMatrix.tileToSourceBounds(xyz.tile);
     return TileXyzRaster.getAssetsForBounds(req, tileSet, xyz.tileMatrix, tileBounds, xyz.tile.z);
   },
 
   async tile(req: LambdaHttpRequest, tileSet: ConfigTileSetRaster, xyz: TileXyz): Promise<LambdaHttpResponse> {
-    if (xyz.tileType === VectorFormat.MapboxVectorTiles) return NotFound();
+    const tileOutput = Validate.pipeline(tileSet, xyz.tileType, xyz.pipeline);
+    if (tileOutput == null) return NotFound();
+    req.set('pipeline', tileOutput.name);
 
     const assetPaths = await this.getAssetsForTile(req, tileSet, xyz);
     const cacheKey = Etag.key(assetPaths);
@@ -132,10 +134,12 @@ export const TileXyzRaster = {
 
     const res = await TileComposer.compose({
       layers,
-      format: xyz.tileType,
-      background: tileSet.background ?? DefaultBackground,
-      resizeKernel: tileSet.resizeKernel ?? DefaultResizeKernel,
+      pipeline: tileOutput.pipeline,
+      format: xyz.tileType as ImageFormat,
+      background: tileOutput.background ?? tileSet.background ?? DefaultBackground,
+      resizeKernel: tileOutput.resizeKernel ?? tileSet.resizeKernel ?? DefaultResizeKernel,
       metrics: req.timer,
+      log: req.log,
     });
 
     req.set('layersUsed', res.layers);

package/src/routes/tile.xyz.ts

@@ -1,5 +1,6 @@
 import { TileSetType } from '@basemaps/config';
 import { LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+
 import { ConfigLoader } from '../util/config.loader.js';
 import { NotFound } from '../util/response.js';
 import { Validate } from '../util/validate.js';

package/src/routes/tile.xyz.vector.ts

@@ -1,6 +1,8 @@
 import { ConfigTileSetVector } from '@basemaps/config';
-import { GoogleTms, VectorFormat } from '@basemaps/geo';
+import { GoogleTms } from '@basemaps/geo';
+import { fsa } from '@basemaps/shared';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+
 import { isGzip } from '../util/cotar.serve.js';
 import { Etag } from '../util/etag.js';
 import { NoContent, NotFound, NotModified } from '../util/response.js';
@@ -10,7 +12,7 @@ import { TileXyz } from '../util/validate.js';
 export const tileXyzVector = {
   /** Serve a MVT vector tile */
   async tile(req: LambdaHttpRequest, tileSet: ConfigTileSetVector, xyz: TileXyz): Promise<LambdaHttpResponse> {
-    if (xyz.tileType !== VectorFormat.MapboxVectorTiles) return NotFound();
+    if (xyz.tileType !== 'pbf') return NotFound();
     if (xyz.tileMatrix.identifier !== GoogleTms.identifier) return NotFound();
 
     if (tileSet.layers.length > 1) return new LambdaHttpResponse(500, 'Too many layers in tileset');
@@ -28,7 +30,7 @@ export const tileXyzVector = {
     if (Etag.isNotModified(req, cacheKey)) return NotModified();
 
     req.timer.start('cotar:load');
-    const cotar = await CoSources.getCotar(layerId);
+    const cotar = await CoSources.getCotar(fsa.toUrl(layerId));
     if (cotar == null) return new LambdaHttpResponse(500, 'Failed to load VectorTiles');
     req.timer.end('cotar:load');
 

package/src/routes/version.ts

@@ -8,17 +8,17 @@ export async function versionGet(): Promise<LambdaHttpResponse> {
      * last git version tag
      * @example "v6.42.1"
      */
-    version: process.env.GIT_VERSION ?? 'dev',
+    version: process.env['GIT_VERSION'] ?? 'dev',
     /**
      * Full git commit hash
      * @example "e4231b1ee62c276c8657c56677ced02681dfe5d6"
      */
-    hash: process.env.GIT_HASH,
+    hash: process.env['GIT_HASH'],
     /**
      * The exact build that this release was run from
      * @example "1658821493-3"
      */
-    buildId: process.env.BUILD_ID,
+    buildId: process.env['BUILD_ID'],
   });
   return response;
 }