@peerbit/log 4.0.10 → 4.0.11

package/src/log.ts

@@ -274,7 +274,7 @@ export class Log<T> {
 	 */
 	async toArray(): Promise<Entry<T>[]> {
 		// we call init, because the values might be unitialized
-		return this.entryIndex.query([], this.sortFn.sort, true).all();
+		return this.entryIndex.iterate([], this.sortFn.sort, true).all();
 	}
 
 	/**
@@ -456,7 +456,7 @@ export class Log<T> {
 			}
 		}
 
-		await this.load({ reload: false });
+		/* await this.load({ reload: false }); */
 
 		const nexts: Sorting.SortableEntry[] =
 			options.meta?.next ||
@@ -554,10 +554,12 @@ export class Log<T> {
 	}
 
 	async remove(
-		entry: ShallowOrFullEntry<T> | ShallowOrFullEntry<T>[],
+		entry:
+			| { hash: string; meta: { next: string[] } }
+			| { hash: string; meta: { next: string[] } }[],
 		options?: { recursively?: boolean },
 	): Promise<Change<T>> {
-		await this.load({ reload: false });
+		/* await this.load({ reload: false }); */
 		const entries = Array.isArray(entry) ? entry : [entry];
 
 		if (entries.length === 0) {
@@ -567,46 +569,34 @@ export class Log<T> {
 			};
 		}
 
-		const change: Change<T> = {
-			added: [],
-			removed: Array.isArray(entry) ? entry : [entry],
-		};
-
-		await this._onChange?.(change);
+		let removed: {
+			entry: ShallowOrFullEntry<T>;
+			fn: () => Promise<ShallowEntry | undefined>;
+		}[];
 
 		if (options?.recursively) {
-			await this.deleteRecursively(entry);
+			removed = await this.prepareDeleteRecursively(entry);
 		} else {
+			removed = [];
 			for (const entry of entries) {
-				await this.delete(entry.hash);
+				const deleteFn = await this.prepareDelete(entry.hash);
+				deleteFn.entry &&
+					removed.push({ entry: deleteFn.entry, fn: deleteFn.fn });
 			}
 		}
 
-		return change;
-	}
+		const change: Change<T> = {
+			added: [],
+			removed: removed.map((x) => x.entry),
+		};
 
-	/* iterator(options?: {
-		from?: "tail" | "head";
-		amount?: number;
-	}): IterableIterator<string> {
-		const from = options?.from || "tail";
-		const amount = typeof options?.amount === "number" ? options?.amount : -1;
-		let next = from === "tail" ? this._values.tail : this._values.head;
-		const nextFn = from === "tail" ? (e: any) => e.prev : (e: any) => e.next;
-		return (function* () {
-			let counter = 0;
-			while (next) {
-				if (amount >= 0 && counter >= amount) {
-					return;
-				}
+		await this._onChange?.(change);
 
-				yield next.value;
-				counter++;
+		// invoke deletions
+		await Promise.all(removed.map((x) => x.fn()));
 
-				next = nextFn(next);
-			}
-		})();
-	} */
+		return change;
+	}
 
 	async trim(option: TrimOptions | undefined = this._trim.options) {
 		return this._trim.trim(option);
@@ -699,18 +689,25 @@ export class Log<T> {
 				heads.set(next, false);
 			}
 		}
+
 		for (const entry of entries) {
 			let isHead = heads.get(entry.hash)!;
-			const p = this.joinRecursively(entry, {
-				references,
-				isHead,
-				...options,
-			});
-			this._joining.set(entry.hash, p);
-			p.finally(() => {
-				this._joining.delete(entry.hash);
-			});
-			await p;
+			let prev = this._joining.get(entry.hash);
+			if (prev) {
+				await prev;
+			} else {
+				const p = this.joinRecursively(entry, {
+					references,
+					isHead,
+					...options,
+				});
+
+				this._joining.set(entry.hash, p);
+				p.finally(() => {
+					this._joining.delete(entry.hash);
+				});
+				await p;
+			}
 		}
 	}
 
@@ -774,7 +771,10 @@ export class Log<T> {
 
 		if (entry.meta.type !== EntryType.CUT) {
 			for (const a of entry.meta.next) {
-				if (!(await this.has(a))) {
+				const prev = this._joining.get(a);
+				if (prev) {
+					await prev;
+				} else if (!(await this.has(a))) {
 					const nested =
 						options.references?.get(a) ||
 						(await Entry.fromMultihash<T>(this._storage, a, {
@@ -839,29 +839,47 @@ export class Log<T> {
 		return [];
 	}
 
-	/// TODO simplify methods below
 	async deleteRecursively(
-		from: ShallowOrFullEntry<T> | ShallowOrFullEntry<T>[],
+		from:
+			| { hash: string; meta: { next: string[] } }
+			| { hash: string; meta: { next: string[] } }[],
+		skipFirst = false,
+	) {
+		const toDelete = await this.prepareDeleteRecursively(from, skipFirst);
+		const promises = toDelete.map(async (x) => {
+			const removed = await x.fn();
+			if (removed) {
+				return removed;
+			}
+			return undefined;
+		});
+
+		const results = Promise.all(promises);
+		return (await results).filter((x) => x) as ShallowEntry[];
+	}
+
+	/// TODO simplify methods below
+	async prepareDeleteRecursively(
+		from:
+			| { hash: string; meta: { next: string[] } }
+			| { hash: string; meta: { next: string[] } }[],
 		skipFirst = false,
 	) {
 		const stack = Array.isArray(from) ? [...from] : [from];
 		const promises: (Promise<void> | void)[] = [];
 		let counter = 0;
-		const deleted: ShallowEntry[] = [];
+		const toDelete: {
+			entry: ShallowOrFullEntry<T>;
+			fn: () => Promise<ShallowEntry | undefined>;
+		}[] = [];
 
 		while (stack.length > 0) {
 			const entry = stack.pop()!;
 			const skip = counter === 0 && skipFirst;
 			if (!skip) {
-				const has = await this.has(entry.hash);
-				if (has) {
-					// TODO test last argument: It is for when multiple heads point to the same entry, hence we might visit it multiple times? or a concurrent delete process is doing it before us.
-					const deletedEntry = await this.delete(entry.hash);
-					if (deletedEntry) {
-						/* 	this._nextsIndex.delete(entry.hash); */
-						deleted.push(deletedEntry);
-					}
-				}
+				const deleteFn = await this.prepareDelete(entry.hash);
+				deleteFn.entry &&
+					toDelete.push({ entry: deleteFn.entry, fn: deleteFn.fn });
 			}
 
 			for (const next of entry.meta.next) {
@@ -871,7 +889,7 @@ export class Log<T> {
 				// if there are no entries which is not of "CUT" type, we can safely delete the next entry
 				// figureately speaking, these means where are cutting all branches to a stem, so we can delete the stem as well
 				let hasAlternativeNext = !!entriesThatHasNext.find(
-					(x) => x.meta.type !== EntryType.CUT,
+					(x) => x.meta.type !== EntryType.CUT && x.hash !== entry.hash, // second arg is to avoid references to the same entry that is to be deleted (i.e we are looking for other entries)
 				);
 				if (!hasAlternativeNext) {
 					const ne = await this.get(next);
@@ -883,13 +901,32 @@ export class Log<T> {
 			counter++;
 		}
 		await Promise.all(promises);
-		return deleted;
+		return toDelete;
+	}
+
+	async prepareDelete(
+		hash: string,
+	): Promise<
+		| { entry: ShallowEntry; fn: () => Promise<ShallowEntry | undefined> }
+		| { entry: undefined }
+	> {
+		let entry = await this._entryIndex.getShallow(hash);
+		if (!entry) {
+			return { entry: undefined };
+		}
+		return {
+			entry: entry.value,
+			fn: async () => {
+				await this._trim.deleteFromCache(hash);
+				const removedEntry = await this._entryIndex.delete(hash, entry.value);
+				return removedEntry;
+			},
+		};
 	}
 
 	async delete(hash: string): Promise<ShallowEntry | undefined> {
-		await this._trim.deleteFromCache(hash);
-		const removedEntry = await this._entryIndex.delete(hash);
-		return removedEntry;
+		const deleteFn = await this.prepareDelete(hash);
+		return deleteFn.entry && deleteFn.fn();
 	}
 
 	/**
@@ -1003,7 +1040,7 @@ export class Log<T> {
 
 		const heads = providedCustomHeads
 			? (opts["heads"] as Array<Entry<T>>)
-			: await this._entryIndex
+			: await this.entryIndex
 					.getHeads(undefined, {
 						type: "full",
 						signal: this._closeController.signal,

package/src/trim.ts

@@ -1,5 +1,4 @@
 import { Cache } from "@peerbit/cache";
-import { SumRequest } from "@peerbit/indexer-interface";
 import PQueue from "p-queue";
 import type { EntryIndex } from "./entry-index.js";
 import type { ShallowEntry } from "./entry-shallow.js";
@@ -141,9 +140,7 @@ export class Trim<T> {
 			// TODO calculate the sum and cache it and update it only when entries are added or removed
 			const byteLengthFn = async () =>
 				BigInt(
-					await this._log.index.properties.index.sum(
-						new SumRequest({ key: "payloadSize" }),
-					),
+					await this._log.index.properties.index.sum({ key: "payloadSize" }),
 				);
 
 			// prune to max sum payload sizes in bytes