mirrors/PMTiles
1
0
Fork 0
mirror of https://github.com/protomaps/PMTiles.git synced 2026-02-04 10:51:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

lint cloudflare implementation (#352)

Browse Source 
Add linters to AWS and cloudflare implementations [#287]
This commit is contained in:
Brandon Liu
2024-02-05 16:59:06 +08:00
committed by GitHub
parent b229c1a8c7
commit e86dd554be
9 changed files with 598 additions and 126 deletions
Download Patch File Download Diff File Expand all files Collapse all files

119
serverless/cloudflare/src/index.ts
View File

@@ -1,26 +1,27 @@
import {
Compression,
PMTiles,
Source,
RangeResponse,
ResolvedValueCache,
Source,
TileType,
Compression,
} from "../../../js/index";
import { pmtiles_path, tile_path, tileJSON } from "../../shared/index";
import { pmtiles_path, tileJSON, tile_path } from "../../shared/index";
interface Env {
// biome-ignore lint: config name
ALLOWED_ORIGINS?: string;
// biome-ignore lint: config name
BUCKET: R2Bucket;
// biome-ignore lint: config name
CACHE_MAX_AGE?: number;
// biome-ignore lint: config name
PMTILES_PATH?: string;
// biome-ignore lint: config name
PUBLIC_HOSTNAME?: string;
}
class KeyNotFoundError extends Error {
constructor(message: string) {
super(message);
}
}
class KeyNotFoundError extends Error {}
async function nativeDecompress(
buf: ArrayBuffer,
@@ -28,33 +29,38 @@ async function nativeDecompress(
): Promise<ArrayBuffer> {
if (compression === Compression.None || compression === Compression.Unknown) {
return buf;
} else if (compression === Compression.Gzip) {
let stream = new Response(buf).body!;
let result = stream.pipeThrough(new DecompressionStream("gzip"));
return new Response(result).arrayBuffer();
} else {
throw Error("Compression method not supported");
}
if (compression === Compression.Gzip) {
const stream = new Response(buf).body;
const result = stream?.pipeThrough(new DecompressionStream("gzip"));
return new Response(result).arrayBuffer();
}
throw Error("Compression method not supported");
}
const CACHE = new ResolvedValueCache(25, undefined, nativeDecompress);
class R2Source implements Source {
env: Env;
archive_name: string;
archiveName: string;
constructor(env: Env, archive_name: string) {
constructor(env: Env, archiveName: string) {
this.env = env;
this.archive_name = archive_name;
this.archiveName = archiveName;
}
getKey() {
return this.archive_name;
return this.archiveName;
}
async getBytes(offset: number, length: number, signal?: AbortSignal, etag?: string): Promise<RangeResponse> {
async getBytes(
offset: number,
length: number,
signal?: AbortSignal,
etag?: string
): Promise<RangeResponse> {
const resp = await this.env.BUCKET.get(
pmtiles_path(this.archive_name, this.env.PMTILES_PATH),
pmtiles_path(this.archiveName, this.env.PMTILES_PATH),
{
range: { offset: offset, length: length },
}
@@ -88,73 +94,72 @@ export default {
const cache = caches.default;
if (ok) {
let allowed_origin = "";
let allowedOrigin = "";
if (typeof env.ALLOWED_ORIGINS !== "undefined") {
for (const o of env.ALLOWED_ORIGINS.split(",")) {
if (o === request.headers.get("Origin") || o === "*") {
allowed_origin = o;
allowedOrigin = o;
}
}
}
const cached = await cache.match(request.url);
if (cached) {
const resp_headers = new Headers(cached.headers);
if (allowed_origin)
resp_headers.set("Access-Control-Allow-Origin", allowed_origin);
resp_headers.set("Vary", "Origin");
const respHeaders = new Headers(cached.headers);
if (allowedOrigin)
respHeaders.set("Access-Control-Allow-Origin", allowedOrigin);
respHeaders.set("Vary", "Origin");
return new Response(cached.body, {
headers: resp_headers,
headers: respHeaders,
status: cached.status,
});
}
const cacheableResponse = (
body: ArrayBuffer | string | undefined,
cacheable_headers: Headers,
cacheableHeaders: Headers,
status: number
) => {
cacheable_headers.set(
cacheableHeaders.set(
"Cache-Control",
"max-age=" + (env.CACHE_MAX_AGE || 86400)
`max-age=${env.CACHE_MAX_AGE || 86400}`
);
const cacheable = new Response(body, {
headers: cacheable_headers,
headers: cacheableHeaders,
status: status,
});
// normalize HEAD requests
ctx.waitUntil(cache.put(request.url, cacheable));
const resp_headers = new Headers(cacheable_headers);
if (allowed_origin)
resp_headers.set("Access-Control-Allow-Origin", allowed_origin);
resp_headers.set("Vary", "Origin");
return new Response(body, { headers: resp_headers, status: status });
const respHeaders = new Headers(cacheableHeaders);
if (allowedOrigin)
respHeaders.set("Access-Control-Allow-Origin", allowedOrigin);
respHeaders.set("Vary", "Origin");
return new Response(body, { headers: respHeaders, status: status });
};
const cacheable_headers = new Headers();
const cacheableHeaders = new Headers();
const source = new R2Source(env, name);
const p = new PMTiles(source, CACHE, nativeDecompress);
try {
const p_header = await p.getHeader();
const pHeader = await p.getHeader();
if (!tile) {
cacheable_headers.set("Content-Type", "application/json");
cacheableHeaders.set("Content-Type", "application/json");
const t = tileJSON(
p_header,
pHeader,
await p.getMetadata(),
env.PUBLIC_HOSTNAME || url.hostname,
name
);
return cacheableResponse(JSON.stringify(t), cacheable_headers, 200);
return cacheableResponse(JSON.stringify(t), cacheableHeaders, 200);
}
if (tile[0] < p_header.minZoom || tile[0] > p_header.maxZoom) {
return cacheableResponse(undefined, cacheable_headers, 404);
if (tile[0] < pHeader.minZoom || tile[0] > pHeader.maxZoom) {
return cacheableResponse(undefined, cacheableHeaders, 404);
}
for (const pair of [
@@ -164,14 +169,14 @@ export default {
[TileType.Webp, "webp"],
[TileType.Avif, "avif"],
]) {
if (p_header.tileType === pair[0] && ext !== pair[1]) {
if (p_header.tileType == TileType.Mvt && ext === "pbf") {
if (pHeader.tileType === pair[0] && ext !== pair[1]) {
if (pHeader.tileType === TileType.Mvt && ext === "pbf") {
// allow this for now. Eventually we will delete this in favor of .mvt
continue;
}
return cacheableResponse(
`Bad request: requested .${ext} but archive has type .${pair[1]}`,
cacheable_headers,
cacheableHeaders,
400
);
}
@@ -179,32 +184,30 @@ export default {
const tiledata = await p.getZxy(tile[0], tile[1], tile[2]);
switch (p_header.tileType) {
switch (pHeader.tileType) {
case TileType.Mvt:
cacheable_headers.set("Content-Type", "application/x-protobuf");
cacheableHeaders.set("Content-Type", "application/x-protobuf");
break;
case TileType.Png:
cacheable_headers.set("Content-Type", "image/png");
cacheableHeaders.set("Content-Type", "image/png");
break;
case TileType.Jpeg:
cacheable_headers.set("Content-Type", "image/jpeg");
cacheableHeaders.set("Content-Type", "image/jpeg");
break;
case TileType.Webp:
cacheable_headers.set("Content-Type", "image/webp");
cacheableHeaders.set("Content-Type", "image/webp");
break;
}
if (tiledata) {
return cacheableResponse(tiledata.data, cacheable_headers, 200);
} else {
return cacheableResponse(undefined, cacheable_headers, 204);
return cacheableResponse(tiledata.data, cacheableHeaders, 200);
}
return cacheableResponse(undefined, cacheableHeaders, 204);
} catch (e) {
if (e instanceof KeyNotFoundError) {
return cacheableResponse("Archive not found", cacheable_headers, 404);
} else {
throw e;
return cacheableResponse("Archive not found", cacheableHeaders, 404);
}
throw e;
}
}