@peerbit/any-store 2.0.0 → 2.0.2-0691c73

package/src/opfs-worker-messages.ts

@@ -1,210 +0,0 @@
-import { field, variant, vec, option } from "@dao-xyz/borsh";
-import { v4 as uuid } from "uuid";
-
-export const levelKey = (level: string[]) => JSON.stringify(level);
-
-@variant(0)
-export class MemoryRequest {
-	@field({ type: "string" })
-	messageId: string;
-
-	constructor(messageId?: Uint8Array) {
-		this.messageId = messageId || uuid();
-	}
-}
-
-@variant(0)
-export abstract class MemoryMessage extends MemoryRequest {
-	@field({ type: vec("string") })
-	level: string[]; // [] means root, ['x'] means sublevel named 'x'
-
-	constructor(properties: { level: string[] }) {
-		super();
-		this.level = properties.level;
-	}
-}
-
-@variant(0)
-export class REQ_Status extends MemoryMessage {}
-
-@variant(1)
-export class RESP_Status extends MemoryMessage {
-	@field({ type: "string" })
-	status: "opening" | "open" | "closing" | "closed";
-
-	constructor(properties: {
-		level: string[];
-		status: "opening" | "open" | "closing" | "closed";
-	}) {
-		super(properties);
-		this.status = properties.status;
-	}
-}
-
-@variant(2)
-export class REQ_Open extends MemoryMessage {}
-
-@variant(3)
-export class RESP_Open extends MemoryMessage {}
-
-@variant(4)
-export class REQ_Close extends MemoryMessage {}
-
-@variant(5)
-export class RESP_Close extends MemoryMessage {}
-
-@variant(6)
-export class REQ_Get extends MemoryMessage {
-	@field({ type: "string" })
-	key: string;
-
-	constructor(properties: { level: string[]; key: string }) {
-		super(properties);
-		this.key = properties.key;
-	}
-}
-
-@variant(7)
-export class RESP_Get extends MemoryMessage {
-	@field({ type: option(Uint8Array) })
-	bytes?: Uint8Array;
-
-	constructor(properties: { level: string[]; bytes?: Uint8Array }) {
-		super(properties);
-		this.bytes = properties.bytes;
-	}
-}
-
-@variant(8)
-export class REQ_Put extends MemoryMessage {
-	@field({ type: "string" })
-	key: string;
-
-	@field({ type: Uint8Array })
-	bytes: Uint8Array;
-
-	constructor(properties: { level: string[]; key: string; bytes: Uint8Array }) {
-		super(properties);
-		this.key = properties.key;
-		this.bytes = properties.bytes;
-	}
-}
-
-@variant(9)
-export class RESP_Put extends MemoryMessage {}
-
-@variant(10)
-export class REQ_Del extends MemoryMessage {
-	@field({ type: "string" })
-	key: string;
-
-	constructor(properties: { level: string[]; key: string }) {
-		super(properties);
-		this.key = properties.key;
-	}
-}
-
-@variant(11)
-export class RESP_Del extends MemoryMessage {}
-
-@variant(12)
-export class REQ_Iterator_Next extends MemoryMessage {
-	@field({ type: "string" })
-	id: string;
-
-	@field({ type: "u32" })
-	step: number;
-
-	constructor(properties: { id: string; level: string[] }) {
-		super(properties);
-		this.id = properties.id;
-		this.step = 1;
-	}
-}
-
-@variant(13)
-export class RESP_Iterator_Next extends MemoryMessage {
-	@field({ type: vec("string") })
-	keys: string[];
-
-	@field({ type: vec(Uint8Array) })
-	values: Uint8Array[];
-
-	constructor(properties: {
-		level: string[];
-		keys: string[];
-		values: Uint8Array[];
-	}) {
-		super(properties);
-		this.keys = properties.keys;
-		this.values = properties.values;
-	}
-}
-
-@variant(14)
-export class REQ_Iterator_Stop extends MemoryMessage {
-	@field({ type: "string" })
-	id: string;
-
-	constructor(properties: { id: string; level: string[] }) {
-		super(properties);
-		this.id = properties.id;
-	}
-}
-
-@variant(15)
-export class RESP_Iterator_Stop extends MemoryMessage {}
-
-@variant(16)
-export class REQ_Sublevel extends MemoryMessage {
-	@field({ type: "string" })
-	name: string;
-
-	constructor(properties: { level: string[]; name: string }) {
-		super(properties);
-		this.name = properties.name;
-	}
-}
-
-@variant(17)
-export class RESP_Sublevel extends MemoryMessage {}
-
-@variant(18)
-export class REQ_Clear extends MemoryMessage {}
-
-@variant(19)
-export class RESP_Clear extends MemoryMessage {}
-
-@variant(20)
-export class REQ_Idle extends MemoryMessage {}
-
-@variant(21)
-export class RESP_Idle extends MemoryMessage {}
-
-@variant(22)
-export class REQ_Size extends MemoryMessage {}
-
-@variant(23)
-export class RESP_Size extends MemoryMessage {
-	@field({ type: "u64" })
-	private _size: bigint;
-
-	constructor(properties: { level: string[]; size: number }) {
-		super(properties);
-		this._size = BigInt(properties.size);
-	}
-	get size(): number {
-		return Number(this._size);
-	}
-}
-
-@variant(24)
-export class RESP_Error extends MemoryMessage {
-	@field({ type: "string" })
-	error: string;
-
-	constructor(properties: { level: string[]; error: string }) {
-		super(properties);
-		this.error = properties.error;
-	}
-}

package/src/opfs-worker.ts

@@ -1,347 +0,0 @@
-import { deserialize, serialize } from "@dao-xyz/borsh";
-import { AnyStore } from "./interface.js";
-import * as memory from "./opfs-worker-messages.js";
-import { fromBase64URL, toBase64URL, ready } from "@peerbit/crypto";
-import { BinaryReader, BinaryWriter } from "@dao-xyz/borsh";
-import { waitForResolved } from "@peerbit/time";
-
-const directory = location.hash.split("#")?.[1];
-
-const encodeName = (name: string): string => {
-	// since "/" and perhaps other characters might not be allowed we do encode
-	const writer = new BinaryWriter();
-	writer.string(name);
-	return toBase64URL(writer.finalize());
-};
-
-const decodeName = (name: string): string => {
-	// since "/" and perhaps other characters might not be allowed we do encode
-	const writer = new BinaryReader(fromBase64URL(name));
-	return writer.string();
-};
-
-const waitForSyncAcccess = async (
-	fileHandle: FileSystemFileHandle
-): Promise<FileSystemSyncAccessHandle> => {
-	try {
-		const handle = await fileHandle.createSyncAccessHandle();
-		return handle;
-	} catch (error) {
-		const handle = await waitForResolved(() =>
-			fileHandle.createSyncAccessHandle()
-		);
-		if (!handle) {
-			throw error;
-		}
-		return handle;
-	}
-};
-
-const createWriteHandle = async (fileHandle: FileSystemFileHandle) => {
-	//  In Chrome on GET DOMException: Failed to execute 'createWritable' on 'FileSystemFileHandle': Failed to create swap file
-	// hence below is not used for now
-	/*
-	if (fileHandle.createWritable != null) {
-		return fileHandle.createWritable({ keepExistingData: false });
-	} */
-	return waitForSyncAcccess(fileHandle);
-};
-
-export class OPFSStoreWorker {
-	private _levels: Map<string, AnyStore>;
-	private _rootStore: AnyStore;
-
-	private _memoryIterator: Map<
-		string,
-		AsyncIterator<[string, ArrayBuffer], void, void>
-	>;
-
-	constructor() {
-		const postMessageFn = postMessage;
-		this._memoryIterator = new Map();
-		this._levels = new Map();
-		let isOpen = false;
-
-		const createMemory = (
-			root?: FileSystemDirectoryHandle,
-			levels: string[] = []
-		): AnyStore => {
-			let m: FileSystemDirectoryHandle = root!;
-			let sizeCache: number = 0;
-			const sizeMap: Map<string, number> = new Map(); // files size per key
-
-			const calculateSize = async () => {
-				sizeCache = 0;
-				for await (const value of m.values()) {
-					if (value.kind === "file") {
-						try {
-							const handle = await waitForSyncAcccess(value);
-							const handleSize = handle.getSize();
-							sizeMap.set(value.name, handleSize);
-							sizeCache += handleSize;
-							handle.close();
-						} catch (error) {
-							// TODO better error handling.
-							// most commonly error can be thrown when we are invoking getSize and files does not exist (anymore)
-						}
-					}
-				}
-			};
-			// 'open' | 'closed' is just a virtual thing since OPFS is always open as soone as we get the FileSystemDirectoryHandle
-			// TODO remove status? or assume not storage adapters can be closed?
-			const open = async () => {
-				await ready;
-
-				if (!m) {
-					m = await navigator.storage.getDirectory();
-					if (directory) {
-						m = await m.getDirectoryHandle(encodeName(directory), {
-							create: true
-						});
-					}
-					await calculateSize();
-				}
-			};
-			return {
-				clear: async () => {
-					for await (const key of m.keys()) {
-						m.removeEntry(key, { recursive: true });
-					}
-					sizeCache = 0;
-					sizeMap.clear();
-				},
-
-				del: async (key: string) => {
-					const encodedKey = encodeName(key);
-					try {
-						await m.removeEntry(encodedKey, { recursive: true });
-					} catch (error) {
-						if (error instanceof DOMException) {
-							return;
-						} else {
-							throw error;
-						}
-					}
-					const prevSize = sizeMap.get(encodedKey);
-					if (prevSize != null) {
-						sizeCache -= prevSize;
-						sizeMap.delete(encodedKey);
-					}
-				},
-
-				get: async (key: string) => {
-					try {
-						const fileHandle = await m.getFileHandle(encodeName(key));
-						const file = await fileHandle.getFile();
-						const buffer = await file.arrayBuffer();
-						return new Uint8Array(buffer);
-					} catch (error) {
-						if (
-							error instanceof DOMException &&
-							error.name === "NotFoundError"
-						) {
-							return undefined;
-						} else if (error) {
-							return undefined;
-						} else {
-							throw error;
-						}
-					}
-				},
-				put: async (key: string, value: Uint8Array) => {
-					const encodedKey = encodeName(key);
-
-					const fileHandle = await m.getFileHandle(encodedKey, {
-						create: true
-					});
-					const writeFileHandle = await createWriteHandle(fileHandle);
-					writeFileHandle.write(value);
-					writeFileHandle.flush();
-					writeFileHandle.close();
-
-					const prevSize = sizeMap.get(encodedKey);
-					if (prevSize) {
-						sizeCache -= prevSize;
-					}
-					sizeCache += value.byteLength;
-					sizeMap.set(encodedKey, value.byteLength);
-				},
-
-				size: async () => {
-					return sizeCache;
-				},
-				status: () => (isOpen ? "open" : "closed"),
-
-				sublevel: async (name) => {
-					const encodedName = encodeName(name);
-					const fileHandle = await m.getDirectoryHandle(encodedName, {
-						create: true
-					});
-					const sublevel = [...levels, name];
-					const subMemory = createMemory(fileHandle, sublevel);
-					this._levels.set(memory.levelKey(sublevel), subMemory);
-					await subMemory.open();
-					return subMemory;
-				},
-
-				async *iterator(): AsyncGenerator<[string, Uint8Array], void, void> {
-					for await (const v of m.values()) {
-						if (v.kind == "file") {
-							yield [
-								decodeName(v.name),
-								new Uint8Array(await (await v.getFile()).arrayBuffer())
-							];
-						}
-					}
-				},
-				close: async () => {
-					sizeCache = undefined as any; // TODO types
-					isOpen = false;
-					this._memoryIterator.clear();
-				},
-				open
-			};
-		};
-
-		this._rootStore = createMemory();
-
-		self.addEventListener("message", async (ev) => {
-			const message = deserialize(ev["data"], memory.MemoryRequest);
-			try {
-				if (message instanceof memory.MemoryMessage) {
-					if (message instanceof memory.REQ_Open) {
-						if (!isOpen) {
-							await this._rootStore.open();
-							isOpen = true;
-						}
-						await this.respond(
-							message,
-							new memory.RESP_Open({ level: message.level }),
-							postMessageFn
-						);
-						return;
-					}
-
-					const m =
-						message.level.length === 0
-							? this._rootStore
-							: this._levels.get(memory.levelKey(message.level));
-					if (!m) {
-						throw new Error("Recieved memory message for an undefined level");
-					} else if (message instanceof memory.REQ_Clear) {
-						await m.clear();
-						await this.respond(
-							message,
-							new memory.RESP_Clear({ level: message.level }),
-							postMessageFn
-						);
-					} else if (message instanceof memory.REQ_Close) {
-						await m.close();
-						await this.respond(
-							message,
-							new memory.RESP_Close({ level: message.level }),
-							postMessageFn
-						);
-					} else if (message instanceof memory.REQ_Del) {
-						await m.del(message.key);
-						await this.respond(
-							message,
-							new memory.RESP_Del({ level: message.level }),
-							postMessageFn
-						);
-					} else if (message instanceof memory.REQ_Iterator_Next) {
-						let iterator = this._memoryIterator.get(message.id);
-						if (!iterator) {
-							iterator = m.iterator()[Symbol.asyncIterator]();
-							this._memoryIterator.set(message.id, iterator);
-						}
-						const next = await iterator.next();
-						await this.respond(
-							message,
-							new memory.RESP_Iterator_Next({
-								keys: next.done ? [] : [next.value[0]],
-								values: next.done ? [] : [new Uint8Array(next.value[1])],
-								level: message.level
-							}),
-							postMessageFn
-						);
-						if (next.done) {
-							this._memoryIterator.delete(message.id);
-						}
-					} else if (message instanceof memory.REQ_Iterator_Stop) {
-						this._memoryIterator.delete(message.id);
-						await this.respond(
-							message,
-							new memory.RESP_Iterator_Stop({ level: message.level }),
-							postMessageFn
-						);
-					} else if (message instanceof memory.REQ_Get) {
-						const value = await m.get(message.key);
-						await this.respond(
-							message,
-							new memory.RESP_Get({
-								bytes: value ? new Uint8Array(value) : undefined,
-								level: message.level
-							}),
-							postMessageFn
-						);
-					} else if (message instanceof memory.REQ_Put) {
-						await m.put(message.key, message.bytes);
-						await this.respond(
-							message,
-							new memory.RESP_Put({ level: message.level }),
-							postMessageFn
-						);
-					} else if (message instanceof memory.REQ_Size) {
-						await this.respond(
-							message,
-							new memory.RESP_Size({
-								size: await m.size(),
-								level: message.level
-							}),
-							postMessageFn
-						);
-					} else if (message instanceof memory.REQ_Status) {
-						await this.respond(
-							message,
-							new memory.RESP_Status({
-								status: await m.status(),
-								level: message.level
-							}),
-							postMessageFn
-						);
-					} else if (message instanceof memory.REQ_Sublevel) {
-						await m.sublevel(message.name);
-
-						await this.respond(
-							message,
-							new memory.RESP_Sublevel({ level: message.level }),
-							postMessageFn
-						);
-					}
-				}
-			} catch (error) {
-				await this.respond(
-					message,
-					new memory.RESP_Error({
-						error: error?.["message"] || error?.constructor.name,
-						level: message["level"] || []
-					}),
-					postMessageFn
-				);
-			}
-		});
-	}
-
-	async respond(
-		request: memory.MemoryRequest,
-		response: memory.MemoryRequest,
-		postMessageFn = postMessage
-	) {
-		response.messageId = request.messageId;
-		const bytes = serialize(response);
-		postMessageFn(bytes, { transfer: [bytes.buffer] });
-	}
-}
-
-new OPFSStoreWorker();