1
0
silverbullet/web/service_worker.ts
Zef Hemel 5a7a35c759
E2E encryption (prototype) (#601)
Prototype E2E encryption
2023-12-17 11:46:18 +01:00

190 lines
5.7 KiB
TypeScript

import type { FileContent } from "../common/spaces/datastore_space_primitives.ts";
import { simpleHash } from "../common/crypto.ts";
import { DataStore } from "../plugos/lib/datastore.ts";
import { IndexedDBKvPrimitives } from "../plugos/lib/indexeddb_kv_primitives.ts";
const CACHE_NAME = "{{CACHE_NAME}}_{{CONFIG_HASH}}";
const precacheFiles = Object.fromEntries([
"/",
"/.client/logout.html",
"/.client/client.js",
"/.client/favicon.png",
"/.client/iAWriterMonoS-Bold.woff2",
"/.client/iAWriterMonoS-BoldItalic.woff2",
"/.client/iAWriterMonoS-Italic.woff2",
"/.client/iAWriterMonoS-Regular.woff2",
"/.client/logo.png",
"/.client/logo-dock.png",
"/.client/main.css",
"/.client/manifest.json",
].map((path) => [path, path + "?v=" + CACHE_NAME, path])); // Cache busting
self.addEventListener("install", (event: any) => {
console.log("[Service worker]", "Installing service worker...");
event.waitUntil(
(async () => {
const cache = await caches.open(CACHE_NAME);
console.log(
"[Service worker]",
"Now pre-caching client files",
);
await cache.addAll(Object.values(precacheFiles));
console.log(
"[Service worker]",
Object.keys(precacheFiles).length,
"client files cached",
);
// @ts-ignore: No need to wait
self.skipWaiting();
})(),
);
});
self.addEventListener("activate", (event: any) => {
console.log("[Service worker]", "Activating new service worker!");
event.waitUntil(
(async () => {
const cacheNames = await caches.keys();
await Promise.all(
cacheNames.map((cacheName) => {
if (cacheName !== CACHE_NAME) {
console.log("[Service worker]", "Removing old cache", cacheName);
return caches.delete(cacheName);
}
}),
);
// @ts-ignore: No need to wait
return clients.claim();
})(),
);
});
let ds: DataStore | undefined;
const filesContentPrefix = ["file", "content"];
self.addEventListener("fetch", (event: any) => {
const url = new URL(event.request.url);
// Use the custom cache key if available, otherwise use the request URL
const cacheKey = precacheFiles[url.pathname] || event.request.url;
event.respondWith(
(async () => {
const request = event.request;
// console.log("Getting request", request, [...request.headers.entries()]);
// Any request with the X-Sync-Mode header originates from the sync engine: pass it on to the server
if (request.headers.has("x-sync-mode")) {
return fetch(request);
}
// Try the static (client) file cache first
const cachedResponse = await caches.match(cacheKey);
// Return the cached response if found
if (cachedResponse) {
return cachedResponse;
}
if (!ds) {
// Not initialzed yet, or in thin client mode, let's just proxy
return fetch(request);
}
const requestUrl = new URL(request.url);
const pathname = requestUrl.pathname;
// Are we fetching a URL from the same origin as the app? If not, we don't handle it and pass it on
if (location.host !== requestUrl.host) {
return fetch(request);
}
if (pathname === "/.auth" || pathname === "/index.json") {
return fetch(request);
} else if (/\/.+\.[a-zA-Z]+$/.test(pathname)) {
// If this is a /*.* request, this can either be a plug worker load or an attachment load
return handleLocalFileRequest(request, pathname);
} else {
// Must be a page URL, let's serve index.html which will handle it
return (await caches.match(precacheFiles["/"])) || fetch(request);
}
})().catch((e) => {
console.warn("[Service worker]", "Fetch failed:", e);
return new Response("Offline", {
status: 503, // Service Unavailable
});
}),
);
});
async function handleLocalFileRequest(
request: Request,
pathname: string,
): Promise<Response> {
const path = decodeURIComponent(pathname.slice(1));
const data = await ds?.get<FileContent>([...filesContentPrefix, path]);
if (data) {
// console.log("Serving from space", path);
return new Response(
data.data,
{
headers: {
"Content-type": data.meta.contentType,
"Content-Length": "" + data.meta.size,
"X-Permission": data.meta.perm,
"X-Created": "" + data.meta.created,
"X-Last-Modified": "" + data.meta.lastModified,
},
},
);
} else if (path.startsWith("!")) {
// Federated URL handling
let url = path.slice(1);
if (url.startsWith("localhost")) {
url = `http://${url}`;
} else {
url = `https://${url}`;
}
console.info("Proxying federated URL", path, "to", url);
return fetch(url, {
method: request.method,
headers: request.headers,
body: request.body,
});
} else {
console.error(
"Did not find file in locally synced space",
path,
);
return new Response("Not found", {
status: 404,
headers: {
"Cache-Control": "no-cache",
},
});
}
}
self.addEventListener("message", (event: any) => {
if (event.data.type === "flushCache") {
caches.delete(CACHE_NAME)
.then(() => {
console.log("[Service worker]", "Cache deleted");
// ds?.close();
event.source.postMessage({ type: "cacheFlushed" });
});
}
if (event.data.type === "config") {
const spaceFolderPath = event.data.config.spaceFolderPath;
const dbPrefix = "" + simpleHash(spaceFolderPath);
// Setup space
const kv = new IndexedDBKvPrimitives(`${dbPrefix}_synced_space`);
kv.init().then(() => {
ds = new DataStore(kv);
console.log("Datastore in service worker initialized...");
});
}
});