@mengine/storage 0.1.0

package/dist/idb.js

@@ -0,0 +1,225 @@
+import { n as BaseDocStorage, t as AutoReconnectConnection } from "./auto-reconnect-0HwaV1v8.js";
+import { Task } from "@mengine/utils";
+import { openDB } from "idb";
+//#region src/impls/idb/schema.ts
+const migrate = (db, oldVersion, _newVersion, trx) => {
+	if (!oldVersion) oldVersion = 0;
+	for (let i = oldVersion; i < migrations.length; i++) migrations[i](db, trx);
+};
+const init = (db) => {
+	db.createObjectStore("snapshots", {
+		keyPath: "docId",
+		autoIncrement: false
+	});
+	db.createObjectStore("updates", {
+		keyPath: ["docId", "seq"],
+		autoIncrement: false
+	}).createIndex("docId", "docId", { unique: false });
+	db.createObjectStore("sequences", {
+		keyPath: "docId",
+		autoIncrement: false
+	});
+	db.createObjectStore("locks", {
+		keyPath: "key",
+		autoIncrement: false
+	});
+};
+const migrations = [init];
+const migrator = {
+	version: migrations.length,
+	migrate
+};
+//#endregion
+//#region src/impls/idb/connection.ts
+var IDBConnection = class extends AutoReconnectConnection {
+	dbName;
+	constructor(dbName) {
+		super();
+		this.dbName = dbName;
+	}
+	get shareId() {
+		return `idb(${migrator.version}):${this.dbName}`;
+	}
+	async doConnect() {
+		const db = await openDB(this.dbName, migrator.version, { upgrade: migrator.migrate });
+		db.addEventListener("versionchange", this.handleVersionChange);
+		return {
+			db,
+			channel: new BroadcastChannel("idb:" + this.dbName)
+		};
+	}
+	doDisconnect(db) {
+		db.db.removeEventListener("versionchange", this.handleVersionChange);
+		db.channel.close();
+		db.db.close();
+	}
+	handleVersionChange = (e) => {
+		if (e.newVersion !== migrator.version) this.error = /* @__PURE__ */ new Error("Database version mismatch, expected " + migrator.version + " but got " + e.newVersion);
+	};
+};
+//#endregion
+//#region src/impls/idb/lock.ts
+var IndexedDBLocker = class {
+	dbConnection;
+	get db() {
+		return this.dbConnection.inner.db;
+	}
+	get channel() {
+		return this.dbConnection.inner.channel;
+	}
+	constructor(dbConnection) {
+		this.dbConnection = dbConnection;
+	}
+	async lock(domain, resource) {
+		const key = `${domain}:${resource}`;
+		return Task.spawn(async () => {
+			while (true) {
+				const trx = this.db.transaction("locks", "readwrite");
+				const record = await trx.store.get(key);
+				if (record) {
+					if (record.lockedAt.getTime() < Date.now() - 3e3) {
+						await trx.store.delete(key);
+						trx.commit();
+						await trx.done;
+					} else trx.abort();
+					continue;
+				}
+				await trx.store.put({
+					key,
+					lockedAt: /* @__PURE__ */ new Date()
+				});
+				trx.commit();
+				await trx.done;
+				return { [Symbol.asyncDispose]: async () => {
+					const trx = this.db.transaction("locks", "readwrite");
+					await trx.store.delete(key);
+					trx.commit();
+					await trx.done;
+				} };
+			}
+		}).timeout(3e3);
+	}
+};
+//#endregion
+//#region src/impls/idb/index.ts
+var IndexedDBDocStorage = class extends BaseDocStorage {
+	static identifier = "IndexedDBDocStorage";
+	connection = new IDBConnection(this.options.dbName);
+	locker = new IndexedDBLocker(this.connection);
+	get db() {
+		return this.connection.inner.db;
+	}
+	get channel() {
+		return this.connection.inner.channel;
+	}
+	async pushDocUpdate(update, origin) {
+		const trx = this.db.transaction([
+			"snapshots",
+			"updates",
+			"sequences"
+		], "readwrite");
+		if (!await trx.objectStore("snapshots").get(update.docId)) {
+			await trx.objectStore("snapshots").put({
+				docId: update.docId,
+				data: update.data,
+				createdAt: /* @__PURE__ */ new Date(),
+				updatedAt: /* @__PURE__ */ new Date()
+			});
+			return;
+		}
+		let seq = await trx.objectStore("sequences").get(update.docId);
+		if (!seq) seq = {
+			docId: update.docId,
+			seq: 0
+		};
+		seq.seq++;
+		await trx.objectStore("sequences").put(seq);
+		await trx.objectStore("updates").put({
+			docId: update.docId,
+			seq: seq.seq,
+			data: update.data,
+			createdAt: /* @__PURE__ */ new Date()
+		});
+		this.event.emit("update", {
+			update: {
+				docId: update.docId,
+				data: update.data
+			},
+			origin
+		});
+		this.channel.postMessage({
+			type: "update",
+			update: {
+				docId: update.docId,
+				data: update.data
+			},
+			origin
+		});
+	}
+	async getDocSnapshot(docId) {
+		return await this.db.transaction("snapshots", "readonly").store.get(docId) ?? null;
+	}
+	async deleteDoc(docId) {
+		{
+			const trx = this.db.transaction(["updates"], "readwrite");
+			const iter = trx.objectStore("updates").index("docId").iterate(IDBKeyRange.only(docId));
+			for await (const { primaryKey } of iter) await trx.objectStore("updates").delete(primaryKey);
+			trx.commit();
+			await trx.done;
+		}
+		{
+			const trx = this.db.transaction(["snapshots"], "readwrite");
+			await trx.objectStore("snapshots").delete(docId);
+			trx.commit();
+		}
+		await this.db.delete("locks", docId);
+		await this.db.delete("sequences", docId);
+	}
+	async setDocSnapshot(snapshot) {
+		const trx = this.db.transaction("snapshots", "readwrite");
+		const record = await trx.store.get(snapshot.docId);
+		if (!record || record.updatedAt <= snapshot.updatedAt) await trx.store.put({
+			docId: snapshot.docId,
+			data: snapshot.data,
+			createdAt: record?.createdAt ?? snapshot.createdAt,
+			updatedAt: snapshot.updatedAt
+		});
+		trx.commit();
+		await trx.done;
+		return true;
+	}
+	async getDocUpdates(docId) {
+		return (await this.db.transaction("updates", "readonly").store.index("docId").getAll(docId)).map((update) => ({
+			docId,
+			seq: update.seq,
+			data: update.data,
+			createdAt: update.createdAt
+		}));
+	}
+	async markUpdatesMerged(docId, updates) {
+		const trx = this.db.transaction("updates", "readwrite");
+		await Promise.all(updates.map((update) => trx.store.delete([docId, update.seq])));
+		trx.commit();
+		await trx.done;
+		return updates.length;
+	}
+	docUpdateListener = 0;
+	subscribeDocUpdate(callback) {
+		if (this.docUpdateListener === 0) this.channel.addEventListener("message", this.handleChannelMessage);
+		this.docUpdateListener++;
+		const dispose = super.subscribeDocUpdate(callback);
+		return () => {
+			dispose();
+			this.docUpdateListener--;
+			if (this.docUpdateListener === 0) this.channel.removeEventListener("message", this.handleChannelMessage);
+		};
+	}
+	handleChannelMessage = (event) => {
+		if (event.data.type === "update") this.event.emit("update", {
+			update: event.data.update,
+			origin: event.data.origin
+		});
+	};
+};
+//#endregion
+export { IndexedDBDocStorage };

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { a as DocStorage, c as DocUpdateRecord, d as Connection, f as ConnectionStatus, i as DocSnapshotRecord, l as share, o as DocStorageOptions, p as DummyConnection, r as DocDiff, s as DocUpdate, t as BaseDocStorage, u as AutoReconnectConnection } from "./base-B0LSXWTK.js";
+export { AutoReconnectConnection, BaseDocStorage, Connection, ConnectionStatus, DocDiff, DocSnapshotRecord, DocStorage, DocStorageOptions, DocUpdate, DocUpdateRecord, DummyConnection, share };

package/dist/index.js

@@ -0,0 +1,27 @@
+import { n as BaseDocStorage, t as AutoReconnectConnection } from "./auto-reconnect-0HwaV1v8.js";
+import { Task } from "@mengine/utils";
+//#region src/connection/api.ts
+var DummyConnection = class {
+	status = "connected";
+	inner;
+	connect() {}
+	disconnect() {}
+	waitForConnected() {
+		return Task.resolve();
+	}
+	onStatusChanged(_cb) {
+		return () => {};
+	}
+};
+//#endregion
+//#region src/connection/shared-connection.ts
+const CONNECTIONS = /* @__PURE__ */ new Map();
+function share(conn) {
+	if (!conn.shareId) throw new Error(`Connection ${conn.constructor.name} is not shareable.\nIf you want to make it shareable, please override [shareId].`);
+	const existing = CONNECTIONS.get(conn.shareId);
+	if (existing) return existing;
+	CONNECTIONS.set(conn.shareId, conn);
+	return conn;
+}
+//#endregion
+export { AutoReconnectConnection, BaseDocStorage, DummyConnection, share };