@peerbit/log 1.0.15 → 2.0.1

package/src/trim.ts

@@ -1,6 +1,6 @@
 import { Cache } from "@peerbit/cache";
 import PQueue from "p-queue";
-import { Entry } from "./entry.js";
+import { Entry, ShallowEntry } from "./entry.js";
 import { EntryNode, Values } from "./values.js";
 
 const trimOptionsEqual = (a: TrimOptions, b: TrimOptions) => {
@@ -68,9 +68,10 @@ export type TrimCondition =
 	| TrimToByteLengthOption
 	| TrimToLengthOption
 	| TrimToTime;
+
 export type TrimCanAppendOption = {
 	filter?: {
-		canTrim: (gid: string) => Promise<boolean> | boolean;
+		canTrim: (entry: ShallowEntry) => Promise<boolean> | boolean;
 		cacheId?: () => string | number;
 	};
 };
@@ -98,7 +99,7 @@ export class Trim<T> {
 	}
 
 	deleteFromCache(entry: Entry<T>) {
-		if (this._canTrimCacheLastNode?.value.hash === entry.hash) {
+		if (this._canTrimCacheLastNode?.value === entry.hash) {
 			this._canTrimCacheLastNode = this._canTrimCacheLastNode.prev;
 		}
 	}
@@ -116,7 +117,7 @@ export class Trim<T> {
 		///  TODO Make this method less ugly
 		const deleted: Entry<T>[] = [];
 
-		let done: () => Promise<boolean> | boolean;
+		let done: () => boolean;
 		const values = this._log.values();
 		if (option.type === "length") {
 			const to = option.to;
@@ -136,18 +137,18 @@ export class Trim<T> {
 		} else if (option.type == "time") {
 			const s0 = BigInt(+new Date() * 1e6);
 			const maxAge = option.maxAge * 1e6;
-			done = async () => {
+			done = () => {
 				if (!values.tail) {
 					return true;
 				}
 
-				const nodeValue = await values.getEntry(values.tail);
+				const nodeValue = values.entryIndex.getShallow(values.tail.value);
 
 				if (!nodeValue) {
 					return true;
 				}
 
-				return s0 - nodeValue.metadata.clock.timestamp.wallTime < maxAge;
+				return s0 - nodeValue.meta.clock.timestamp.wallTime < maxAge;
 			};
 		} else {
 			return [];
@@ -194,7 +195,7 @@ export class Trim<T> {
 		// TODO only go through heads?
 		while (
 			node &&
-			!(await done()) &&
+			!done() &&
 			values.length > 0 &&
 			node &&
 			(!looped || node !== startNode)
@@ -202,15 +203,16 @@ export class Trim<T> {
 			let deleteAble: boolean | undefined = true;
 			if (option.filter?.canTrim) {
 				canTrimByGid = canTrimByGid || new Map();
-				deleteAble = canTrimByGid.get(node.value.gid);
+				const indexedEntry = values.entryIndex.getShallow(node.value)!; // TODO check undefined
+				deleteAble = canTrimByGid.get(indexedEntry.meta.gid);
 				if (deleteAble === undefined) {
-					deleteAble = await option.filter?.canTrim(node.value.gid);
-					canTrimByGid.set(node.value.gid, deleteAble);
+					deleteAble = await option.filter?.canTrim(indexedEntry);
+					canTrimByGid.set(indexedEntry.meta.gid, deleteAble);
 				}
 
 				if (!deleteAble && cacheProgress) {
 					// ignore it
-					this._canTrimCacheHashBreakpoint.add(node.value.hash, true);
+					this._canTrimCacheHashBreakpoint.add(node.value, true);
 				}
 			}
 

package/src/values.ts

@@ -1,25 +1,15 @@
-import { Entry } from "./entry";
+import { Entry, ShallowEntry } from "./entry";
 import { ISortFunction } from "./log-sorting";
 import yallist from "yallist";
 import { EntryIndex } from "./entry-index";
 
-type Storage<T> = (
-	hash: string
-) => Promise<Entry<T> | undefined> | Entry<T> | undefined;
-
-interface Value {
-	hash: string;
-	gid: string;
-	byteLength: number;
-}
-
-export type EntryNode = yallist.Node<Value>;
+export type EntryNode = yallist.Node<string>;
 
 export class Values<T> {
 	/**
 	 * Keep track of sorted elements in descending sort order (i.e. newest elements)
 	 */
-	private _values: yallist<Value>;
+	private _values: yallist<string>;
 	private _sortFn: ISortFunction;
 	private _byteLength: number;
 	private _entryIndex: EntryIndex<T>;
@@ -36,11 +26,15 @@ export class Values<T> {
 				.reverse()
 				.map((x) => {
 					if (!x.hash) throw new Error("Unexpected");
-					return {
+					return x.hash; /* {
 						hash: x.hash,
 						byteLength: x._payload.byteLength,
-						gid: x.gid,
-					};
+						meta: {
+							gids: x.gids,
+							gid: x.gid,
+							data: x.meta.data,
+						},
+					}; */
 				})
 		);
 		this._byteLength = 0;
@@ -53,7 +47,7 @@ export class Values<T> {
 
 	toArray(): Promise<Entry<T>[]> {
 		return Promise.all(
-			this._values.toArrayReverse().map((x) => this._entryIndex.get(x.hash))
+			this._values.toArrayReverse().map((x) => this._entryIndex.get(x))
 		).then((arr) => arr.filter((x) => !!x)) as Promise<Entry<T>[]>; // we do reverse because we assume the log is only meaningful if we read it from start to end
 	}
 
@@ -68,6 +62,10 @@ export class Values<T> {
 	}
 
 	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) {
@@ -85,7 +83,7 @@ export class Values<T> {
 		let walker = this._values.head;
 		let last: EntryNode | undefined = undefined;
 		while (walker) {
-			const walkerValue = await this.getEntry(walker);
+			const walkerValue = await this._entryIndex.getShallow(walker.value);
 			if (!walkerValue) {
 				throw new Error("Missing walker value");
 			}
@@ -106,11 +104,7 @@ export class Values<T> {
 			throw new Error("Unexpected");
 		}
 
-		_insertAfter(this._values, last, {
-			byteLength: value._payload.byteLength,
-			gid: value.gid,
-			hash: value.hash,
-		});
+		_insertAfter(this._values, last, value.hash);
 	}
 
 	async delete(value: Entry<T> | string) {
@@ -119,7 +113,7 @@ export class Values<T> {
 
 		let walker = this._values.tail;
 		while (walker) {
-			const walkerValue = await this.getEntry(walker);
+			const walkerValue = this._entryIndex.getShallow(walker.value);
 
 			if (!walkerValue) {
 				throw new Error("Missing walker value");
@@ -127,7 +121,7 @@ export class Values<T> {
 
 			if (walkerValue.hash === hash) {
 				this._values.removeNode(walker);
-				this._byteLength -= walkerValue._payload.byteLength;
+				this._byteLength -= walkerValue.payloadByteLength;
 				return;
 			}
 			walker = walker.prev; // prev will be undefined if you do removeNode(walker)
@@ -143,14 +137,16 @@ export class Values<T> {
 
 	deleteNode(node: EntryNode) {
 		this._values.removeNode(node);
-		this._byteLength -= node.value.byteLength;
+		this._byteLength -= this._entryIndex.getShallow(
+			node.value
+		)!.payloadByteLength;
 		return;
 	}
 
 	pop() {
 		const value = this._values.pop();
 		if (value) {
-			this._byteLength -= value.byteLength;
+			this._byteLength -= this._entryIndex.getShallow(value)!.payloadByteLength;
 		}
 		return value;
 	}
@@ -158,16 +154,12 @@ export class Values<T> {
 	get byteLength() {
 		return this._byteLength;
 	}
-
-	async getEntry(node: EntryNode) {
-		return this._entryIndex.get(node.value.hash);
-	}
 }
 
 function _insertAfter(
 	self: yallist<any>,
 	node: EntryNode | undefined,
-	value: Value
+	value: string
 ) {
 	const inserted = !node
 		? new yallist.Node(

package/lib/esm/is-defined.d.ts

@@ -1 +0,0 @@
-export declare const isDefined: (arg: any) => boolean;

package/lib/esm/is-defined.js

@@ -1,2 +0,0 @@
-export const isDefined = (arg) => arg !== undefined && arg !== null;
-//# sourceMappingURL=is-defined.js.map

package/lib/esm/is-defined.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-defined.js","sourceRoot":"","sources":["../../src/is-defined.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,GAAQ,EAAE,EAAE,CAAC,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,IAAI,CAAC"}

package/src/is-defined.ts

@@ -1 +0,0 @@
-export const isDefined = (arg: any) => arg !== undefined && arg !== null;