@peerbit/log 2.1.9 → 3.0.1

package/src/hrtime.ts

@@ -28,7 +28,7 @@ SOFTWARE.
 const _perfomancePolyfill = () => {
 	// based on https://gist.github.com/paulirish/5438650 copyright Paul Irish 2015.
 	if ("performance" in window === false) {
-		(window.performance as any) = {};
+		((window as any).performance as any) = {};
 	}
 
 	Date.now =
@@ -45,7 +45,7 @@ const _perfomancePolyfill = () => {
 			nowOffset = performance.timing.navigationStart;
 		}
 
-		window.performance.now = () => Date.now() - nowOffset;
+		(window.performance as any)["now"] = () => Date.now() - nowOffset;
 	}
 };
 

package/src/log.ts

@@ -3,11 +3,10 @@ import {
 	randomBytes,
 	sha256Base64Sync,
 	Identity,
-	Keychain,
 	X25519Keypair
 } from "@peerbit/crypto";
 import { Cache } from "@peerbit/cache";
-import { SimpleLevel } from "@peerbit/lazy-level";
+import { AnyStore } from "@peerbit/any-store";
 
 import { EntryIndex } from "./entry-index.js";
 import * as LogError from "./log-errors.js";
@@ -37,6 +36,7 @@ import { Change } from "./change.js";
 import { EntryWithRefs } from "./entry-with-refs.js";
 import { Blocks } from "@peerbit/blocks-interface";
 import { cidifyString } from "@peerbit/blocks";
+import { Keychain } from "@peerbit/keychain";
 
 const { LastWriteWins, NoZeroes } = Sorting;
 
@@ -46,7 +46,7 @@ export type LogEvents<T> = {
 };
 
 export type MemoryProperties = {
-	cache?: SimpleLevel;
+	cache?: AnyStore;
 };
 
 export type LogProperties<T> = {
@@ -110,7 +110,7 @@ export class Log<T> {
 	private _canAppend?: CanAppend<T>;
 	private _onChange?: (change: Change<T>) => void;
 	private _closed = true;
-	private _memory?: SimpleLevel;
+	private _memory?: AnyStore;
 	private _joining: Map<string, Promise<any>>; // entry hashes that are currently joining into this log
 
 	constructor(properties?: { id?: Uint8Array }) {
@@ -173,6 +173,7 @@ export class Log<T> {
 		this._values = new Values(this._entryIndex, this._sortFn);
 		this._trim = new Trim(
 			{
+				headsIndex: this._headsIndex,
 				deleteNode: async (node: EntryNode) => {
 					// TODO check if we have before delete?
 					const entry = await this.get(node.value);
@@ -180,19 +181,20 @@ export class Log<T> {
 					const a = this.values.length;
 					if (entry) {
 						this.values.deleteNode(node);
-						await this.headsIndex.del(this.entryIndex.getShallow(node.value)!);
-						await this.entryIndex.delete(node.value);
+						await Promise.all([
+							this.headsIndex.del(this.entryIndex.getShallow(node.value)!),
+							this.entryIndex.delete(node.value)
+						]);
 						this.nextsIndex.delete(node.value);
-						await this.storage.rm(node.value);
+						await this.blocks.rm(node.value);
 					}
 					const b = this.values.length;
 					if (a === b) {
-						throw new Error(
-							"UNexpected: " +
-								this.values.length +
-								"_-- " +
-								this.entryIndex._index.size
-						);
+						/* throw new Error(
+							"Unexpected miss match between log size and entry index size: " +
+							this.values.length +
+							this.entryIndex._index.size
+						); */
 					}
 					return entry;
 				},
@@ -276,7 +278,7 @@ export class Log<T> {
 		return this._headsIndex;
 	}
 
-	get memory(): SimpleLevel | undefined {
+	get memory(): AnyStore | undefined {
 		return this._memory;
 	}
 
@@ -328,7 +330,7 @@ export class Log<T> {
 		return this._identity;
 	}
 
-	get storage(): Blocks {
+	get blocks(): Blocks {
 		return this._storage;
 	}
 
@@ -554,7 +556,7 @@ export class Log<T> {
 						receiver: {
 							...options.encryption.receiver
 						}
-				  }
+					}
 				: undefined,
 			canAppend: this._canAppend
 		});
@@ -581,7 +583,6 @@ export class Log<T> {
 		const removed = await this.processEntry(entry);
 
 		entry.init({ encoding: this._encoding, keychain: this._keychain });
-		//	console.log('put entry', entry.hash, (await this._entryIndex._index.size));
 
 		const trimmed = await this.trim(options?.trim);
 
@@ -939,16 +940,15 @@ export class Log<T> {
 		const promises: Promise<void>[] = [];
 		let counter = 0;
 		const deleted: Entry<T>[] = [];
-		const deletedGids = new Set();
 
 		while (stack.length > 0) {
 			const entry = stack.pop()!;
 			if ((counter > 0 || !skipFirst) && this.has(entry.hash)) {
 				// 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.
 				this._trim.deleteFromCache(entry);
+				await this._headsIndex.del(entry);
 				await this._values.delete(entry);
 				await this._entryIndex.delete(entry.hash);
-				await this._headsIndex.del(entry);
 
 				this._nextsIndex.delete(entry.hash);
 				deleted.push(entry);
@@ -976,9 +976,9 @@ export class Log<T> {
 
 	async delete(entry: Entry<any>) {
 		this._trim.deleteFromCache(entry);
+		await this._headsIndex.del(entry);
 		await this._values.delete(entry);
 		await this._entryIndex.delete(entry.hash);
-		await this._headsIndex.del(entry);
 		this._nextsIndex.delete(entry.hash);
 		const newHeads: string[] = [];
 		for (const next of entry.next) {
@@ -1049,6 +1049,10 @@ export class Log<T> {
 	async drop() {
 		// Don't return early here if closed = true, because "load" might create processes that needs to be closed
 		this._closed = true; // closed = true before doing below, else we might try to open the headsIndex cache because it is closed as we assume log is still open
+
+		await Promise.all(
+			[...this.entryIndex._index.values()].map((x) => this.blocks.rm(x.hash))
+		);
 		await this._headsIndex?.drop();
 		await this._entryCache?.clear();
 		await this._memory?.clear();
@@ -1107,7 +1111,7 @@ export class Log<T> {
 					timeout: opts.fetchEntryTimeout,
 					reload: opts.reload,
 					cache: { update: true, reset: true }
-			  });
+				});
 
 		if (heads) {
 			// Load the log

package/src/snapshot.ts

@@ -10,8 +10,8 @@ import {
 	variant,
 	vec
 } from "@dao-xyz/borsh";
-import { waitForAsync } from "@peerbit/time";
-import LocalStore from "@peerbit/lazy-level";
+import { waitFor } from "@peerbit/time";
+import { AnyStore } from "@peerbit/any-store";
 import { logger } from "./logger.js";
 
 @variant(0)
@@ -46,7 +46,7 @@ export class Snapshot {
 export const save = async <T>(
 	snapshotPath: string,
 	blockstore: Blocks,
-	cache: LocalStore,
+	cache: AnyStore,
 	log: {
 		id: Uint8Array;
 		getHeads: () => Promise<string[]>;
@@ -68,7 +68,7 @@ export const save = async <T>(
 	writer.string(snapshot);
 	await cache.put(snapshotPath, writer.finalize());
 
-	await waitForAsync(() => cache.get(snapshotPath).then((bytes) => !!bytes), {
+	await waitFor(async () => (await cache.get(snapshotPath)) != null, {
 		delayInterval: 200,
 		timeout: 10 * 1000
 	});
@@ -91,7 +91,7 @@ export const load = async (
 export const loadFromCache = async (
 	path: string,
 	blockstore: Blocks,
-	cache: LocalStore
+	cache: AnyStore
 ) => {
 	const snapshotOrCID = await cache.get(path);
 	if (!snapshotOrCID) {

package/src/trim.ts

@@ -2,6 +2,7 @@ import { Cache } from "@peerbit/cache";
 import PQueue from "p-queue";
 import { Entry, ShallowEntry } from "./entry.js";
 import { EntryNode, Values } from "./values.js";
+import { HeadsIndex } from "./heads.js";
 
 const trimOptionsEqual = (a: TrimOptions, b: TrimOptions) => {
 	if (a.type === b.type) {
@@ -78,6 +79,7 @@ export type TrimCanAppendOption = {
 export type TrimOptions = TrimCanAppendOption & TrimCondition;
 
 interface Log<T> {
+	headsIndex: HeadsIndex<T>;
 	values: () => Values<T>;
 	deleteNode: (node: EntryNode) => Promise<Entry<T> | undefined>;
 }
@@ -86,6 +88,8 @@ export class Trim<T> {
 	private _canTrimCacheLastNode: EntryNode | undefined | null;
 	private _trimLastHead: EntryNode | undefined | null;
 	private _trimLastTail: EntryNode | undefined | null;
+	private _trimLastLength = 0;
+
 	private _trimLastOptions: TrimOptions;
 	private _trimLastSeed: string | number | undefined;
 	private _canTrimCacheHashBreakpoint: Cache<boolean>;
@@ -177,9 +181,10 @@ export class Trim<T> {
 				!this._trimLastOptions ||
 				!trimOptionsEqual(this._trimLastOptions, option);
 
-			const changed =
+			changed =
 				this._trimLastHead !== values.head ||
 				this._trimLastTail !== values.tail ||
+				this._trimLastLength !== this._log.headsIndex.size ||
 				trimOptionsChanged;
 			if (!changed) {
 				return [];
@@ -250,6 +255,7 @@ export class Trim<T> {
 		this._canTrimCacheLastNode = node || lastNode;
 		this._trimLastHead = values.head;
 		this._trimLastTail = values.tail;
+		this._trimLastLength = this._log.headsIndex.size;
 		this._trimLastOptions = option;
 		this._trimLastSeed = seed;
 

package/src/values.ts

@@ -61,29 +61,18 @@ export class Values<T> {
 		return this._values.length;
 	}
 
-	private _putPromise: Map<string, Promise<any>> = new Map();
-
 	get entryIndex(): EntryIndex<T> {
 		return this._entryIndex;
 	}
-	async put(value: Entry<T>) {
-		let promise = this._putPromise.get(value.hash);
-		if (promise) {
-			return promise;
-		}
-		promise = this._put(value).then((v) => {
-			this._putPromise.delete(value.hash);
-			return v;
-		});
-		this._putPromise.set(value.hash, promise);
-		return promise;
+	put(value: Entry<T>) {
+		return this._put(value);
 	}
-	async _put(value: Entry<T>) {
+	_put(value: Entry<T>) {
 		// assume we want to insert at head (or somehere close)
 		let walker = this._values.head;
 		let last: EntryNode | undefined = undefined;
 		while (walker) {
-			const walkerValue = await this._entryIndex.getShallow(walker.value);
+			const walkerValue = this._entryIndex.getShallow(walker.value);
 			if (!walkerValue) {
 				throw new Error("Missing walker value");
 			}
@@ -167,7 +156,7 @@ function _insertAfter(
 				null as any,
 				self.head as EntryNode | undefined,
 				self
-		  )
+			)
 		: new yallist.Node(value, node, node.next as EntryNode | undefined, self);
 
 	// is tail