@peerbit/log 3.0.34-aa577a5 → 3.0.34-cccc078

package/src/entry.ts

@@ -1,33 +1,34 @@
-import { HLC, LamportClock as Clock, Timestamp } from "./clock.js";
 import {
-	variant,
-	field,
-	serialize,
 	deserialize,
+	field,
+	fixedArray,
 	option,
+	serialize,
+	variant,
 	vec,
-	fixedArray,
 } from "@dao-xyz/borsh";
-
+import { type Blocks } from "@peerbit/blocks-interface";
 import {
+	AccessError,
 	DecryptedThing,
+	Ed25519PublicKey,
+	type Identity,
 	MaybeEncrypted,
 	PublicSignKey,
-	X25519PublicKey,
 	SignatureWithKey,
-	AccessError,
-	Ed25519PublicKey,
-	sha256Base64,
+	X25519Keypair,
+	X25519PublicKey,
 	randomBytes,
-	type Identity,
-	X25519Keypair
+	sha256Base64,
 } from "@peerbit/crypto";
 import { verify } from "@peerbit/crypto";
+import { id } from "@peerbit/indexer-interface";
+import { type Keychain } from "@peerbit/keychain";
 import { compare } from "uint8arrays";
+import { LamportClock as Clock, HLC, Timestamp } from "./clock.js";
 import { type Encoding, NO_ENCODING } from "./encoding.js";
+import type { SortableEntry } from "./log-sorting.js";
 import { logger } from "./logger.js";
-import { type Blocks } from "@peerbit/blocks-interface";
-import { type Keychain } from "@peerbit/keychain";
 import { equals } from "./utils.js";
 
 export type MaybeEncryptionPublicKey =
@@ -119,7 +120,7 @@ export class Payload<T> {
 		return this._value;
 	}
 	getValue(encoding: Encoding<T> = this.encoding || NO_ENCODING): T {
-		if (this._value != undefined) {
+		if (this._value !== undefined) {
 			return this._value;
 		}
 		return encoding.decoder(this.data);
@@ -134,10 +135,10 @@ export interface EntryEncryptionTemplate<A, B, C> {
 
 export enum EntryType {
 	APPEND = 0, // Add more data
-	CUT = 1 // Delete or Create tombstone ... delete all nexts, i
+	CUT = 1, // Delete or Create tombstone ... delete all nexts, i
 }
 
-@variant(0)
+/* @variant(0) */
 export class Meta {
 	@field({ type: Clock })
 	clock: Clock;
@@ -196,7 +197,7 @@ export class Signatures {
 const maybeEncrypt = <Q>(
 	thing: Q,
 	keypair?: X25519Keypair,
-	receiver?: MaybeEncryptionPublicKey
+	receiver?: MaybeEncryptionPublicKey,
 ): Promise<MaybeEncrypted<Q>> | MaybeEncrypted<Q> => {
 	const receivers = receiver
 		? Array.isArray(receiver)
@@ -209,26 +210,41 @@ const maybeEncrypt = <Q>(
 		}
 		return new DecryptedThing<Q>({
 			data: serialize(thing),
-			value: thing
+			value: thing,
 		}).encrypt(keypair, receivers);
 	}
 	return new DecryptedThing<Q>({
 		data: serialize(thing),
-		value: thing
+		value: thing,
 	});
 };
 
-export interface ShallowEntry {
+export class ShallowEntry {
+	@id({ type: "string" })
 	hash: string;
-	meta: {
-		clock: Clock;
-		data?: Uint8Array;
-		gid: string;
-		next: string[];
-		type: EntryType;
-	};
-	payloadByteLength: number;
+
+	@field({ type: Meta })
+	meta: Meta;
+
+	@field({ type: "u32" })
+	payloadSize: number;
+
+	@field({ type: "bool" })
+	head: boolean;
+
+	constructor(properties: {
+		hash: string;
+		meta: Meta;
+		payloadSize: number;
+		head: boolean;
+	}) {
+		this.hash = properties.hash;
+		this.meta = properties.meta;
+		this.payloadSize = properties.payloadSize;
+		this.head = properties.head;
+	}
 }
+export type ShallowOrFullEntry<T> = ShallowEntry | Entry<T>;
 
 @variant(0)
 export class Entry<T>
@@ -272,11 +288,11 @@ export class Entry<T>
 	init(
 		props:
 			| {
-				keychain?: Keychain;
-				encoding: Encoding<T>;
-			}
-			| Entry<T>
-	): Entry<T> {
+					keychain?: Keychain;
+					encoding: Encoding<T>;
+			  }
+			| Entry<T>,
+	): this {
 		if (props instanceof Entry) {
 			this._keychain = props._keychain;
 			this._encoding = props._encoding;
@@ -361,7 +377,7 @@ export class Entry<T>
 	get size(): number {
 		if (this._size == null) {
 			throw new Error(
-				"Size not set. Size is set when entry is, created, loaded or joined"
+				"Size not set. Size is set when entry is, created, loaded or joined",
 			);
 		}
 		return this._size;
@@ -373,6 +389,7 @@ export class Entry<T>
 	get signatures(): SignatureWithKey[] {
 		const signatures = this._signatures!.signatures.filter((x) => {
 			try {
+				// eslint-disable-next-line @typescript-eslint/no-unused-expressions
 				x.decrypted;
 				return true;
 			} catch (error) {
@@ -391,7 +408,7 @@ export class Entry<T>
 	 */
 	async getSignatures(): Promise<SignatureWithKey[]> {
 		const results = await Promise.allSettled(
-			this._signatures!.signatures.map((x) => x.decrypt(this._keychain))
+			this._signatures!.signatures.map((x) => x.decrypt(this._keychain)),
 		);
 
 		if (logger.level === "debug" || logger.level === "trace") {
@@ -432,7 +449,7 @@ export class Entry<T>
 			payload: entry._payload,
 			reserved: entry._reserved,
 			signatures: undefined,
-			hash: undefined
+			hash: undefined,
 		});
 		return trimmed;
 	}
@@ -477,14 +494,14 @@ export class Entry<T>
 			type?: EntryType;
 			gidSeed?: Uint8Array;
 			data?: Uint8Array;
-			next?: Entry<T>[];
+			next?: SortableEntry[];
 		};
 		encoding?: Encoding<T>;
 		canAppend?: CanAppend<T>;
 		encryption?: EntryEncryption;
 		identity: Identity;
 		signers?: ((
-			data: Uint8Array
+			data: Uint8Array,
 		) => Promise<SignatureWithKey> | SignatureWithKey)[];
 	}): Promise<Entry<T>> {
 		if (!properties.encoding || !properties?.meta?.next) {
@@ -492,9 +509,9 @@ export class Entry<T>
 				...properties,
 				meta: {
 					...properties?.meta,
-					next: properties.meta?.next ? properties.meta?.next : []
+					next: properties.meta?.next ? properties.meta?.next : [],
 				},
-				encoding: properties.encoding ? properties.encoding : NO_ENCODING
+				encoding: properties.encoding ? properties.encoding : NO_ENCODING,
 			};
 		}
 
@@ -512,7 +529,7 @@ export class Entry<T>
 		const payloadToSave = new Payload<T>({
 			data: properties.encoding.encoder(properties.data),
 			value: properties.data,
-			encoding: properties.encoding
+			encoding: properties.encoding,
 		});
 
 		let clock: Clock | undefined = properties.meta?.clock;
@@ -527,12 +544,12 @@ export class Entry<T>
 				properties.encryption?.receiver.meta
 			) {
 				throw new Error(
-					"Signature is to be encrypted yet the clock is not, which contains the publicKey as id. Either provide a custom Clock value that is not sensitive or set the receiver (encryption target) for the clock"
+					"Signature is to be encrypted yet the clock is not, which contains the publicKey as id. Either provide a custom Clock value that is not sensitive or set the receiver (encryption target) for the clock",
 				);
 			}
 			clock = new Clock({
 				id: properties.identity.publicKey.bytes,
-				timestamp: hlc.now()
+				timestamp: hlc.now(),
 			});
 		} else {
 			const cv = clock;
@@ -541,9 +558,9 @@ export class Entry<T>
 				if (Timestamp.compare(n.meta.clock.timestamp, cv.timestamp) >= 0) {
 					throw new Error(
 						"Expecting next(s) to happen before entry, got: " +
-						n.meta.clock.timestamp +
-						" > " +
-						cv.timestamp
+							n.meta.clock.timestamp +
+							" > " +
+							cv.timestamp,
 					);
 				}
 			}
@@ -556,7 +573,7 @@ export class Entry<T>
 			// take min gid as our gid
 			if (properties.meta?.gid) {
 				throw new Error(
-					"Expecting '.meta.gid' property to be undefined if '.meta.next' is provided"
+					"Expecting '.meta.gid' property to be undefined if '.meta.next' is provided",
 				);
 			}
 			for (const n of nexts) {
@@ -585,16 +602,16 @@ export class Entry<T>
 				gid: gid!,
 				type: properties.meta?.type ?? EntryType.APPEND,
 				data: properties.meta?.data,
-				next: nextHashes
+				next: nextHashes,
 			}),
 			properties.encryption?.keypair,
-			properties.encryption?.receiver.meta
+			properties.encryption?.receiver.meta,
 		);
 
 		const payload = await maybeEncrypt(
 			payloadToSave,
 			properties.encryption?.keypair,
-			properties.encryption?.receiver.payload
+			properties.encryption?.receiver.payload,
 		);
 
 		// Sign id, encrypted payload, clock, nexts, refs
@@ -602,40 +619,40 @@ export class Entry<T>
 			meta: metadataEncrypted,
 			payload,
 			signatures: undefined,
-			createdLocally: true
+			createdLocally: true,
 		});
 
 		const signers = properties.signers || [
-			properties.identity.sign.bind(properties.identity)
+			properties.identity.sign.bind(properties.identity),
 		];
 		const signable = entry.toSignable();
 		const signableBytes = serialize(signable);
 		let signatures = await Promise.all(
-			signers.map((signer) => signer(signableBytes))
+			signers.map((signer) => signer(signableBytes)),
 		);
 		signatures = signatures.sort((a, b) => compare(a.signature, b.signature));
 
 		const encryptedSignatures: MaybeEncrypted<SignatureWithKey>[] = [];
 		const encryptAllSignaturesWithSameKey = isMaybeEryptionPublicKey(
-			properties.encryption?.receiver?.signatures
+			properties.encryption?.receiver?.signatures,
 		);
 
 		for (const signature of signatures) {
 			const encryptionRecievers = encryptAllSignaturesWithSameKey
 				? properties.encryption?.receiver?.signatures
-				: (properties.encryption?.receiver?.signatures as any)?.[ // TODO types
-				signature.publicKey.hashcode()
-				];
+				: (properties.encryption?.receiver?.signatures as any)?.[
+						signature.publicKey.hashcode()
+					]; // TODO types
 			const signatureEncrypted = await maybeEncrypt(
 				signature,
 				properties.encryption?.keypair,
-				encryptionRecievers
+				encryptionRecievers,
 			);
 			encryptedSignatures.push(signatureEncrypted);
 		}
 
 		entry._signatures = new Signatures({
-			signatures: encryptedSignatures
+			signatures: encryptedSignatures,
 		});
 
 		if (properties.canAppend && !(await properties.canAppend(entry))) {
@@ -654,18 +671,19 @@ export class Entry<T>
 		return this._payload.byteLength;
 	}
 
-	toShallow(): ShallowEntry {
-		return {
+	toShallow(isHead: boolean): ShallowEntry {
+		return new ShallowEntry({
 			hash: this.hash,
-			payloadByteLength: this._payload.byteLength,
-			meta: {
+			payloadSize: this._payload.byteLength,
+			head: isHead,
+			meta: new Meta({
 				gid: this.meta.gid,
 				data: this.meta.data,
 				clock: this.meta.clock,
 				next: this.meta.next,
-				type: this.meta.type
-			}
-		};
+				type: this.meta.type,
+			}),
+		});
 	}
 
 	/**
@@ -682,8 +700,7 @@ export class Entry<T>
 
 		const bytes = serialize(entry);
 		entry.size = bytes.length;
-		const result = store.put(bytes);
-		return result;
+		return store.put(bytes);
 	}
 
 	/**
@@ -696,7 +713,7 @@ export class Entry<T>
 	static async fromMultihash<T>(
 		store: Blocks,
 		hash: string,
-		options?: { timeout?: number; replicate?: boolean }
+		options?: { timeout?: number; replicate?: boolean },
 	) {
 		if (!hash) throw new Error(`Invalid hash: ${hash}`);
 		const bytes = await store.get(hash, options);
@@ -740,7 +757,7 @@ export class Entry<T>
 	 * @returns {boolean}
 	 */
 	static isDirectParent<T>(entry1: Entry<T>, entry2: Entry<T>) {
-		return entry2.next.indexOf(entry1.hash as any) > -1; // TODO fix types
+		return entry2.next.includes(entry1.hash as any); // TODO fix types
 	}
 
 	/**
@@ -752,7 +769,7 @@ export class Entry<T>
 	 */
 	static findDirectChildren<T>(
 		entry: Entry<T>,
-		values: Entry<T>[]
+		values: Entry<T>[],
 	): Entry<T>[] {
 		let stack: Entry<T>[] = [];
 		let parent = values.find((e) => Entry.isDirectParent(entry, e));

package/src/heads-cache.ts

@@ -1,14 +1,20 @@
+import {
+	deserialize,
+	field,
+	option,
+	serialize,
+	variant,
+	vec,
+} from "@dao-xyz/borsh";
+import { type AnyStore } from "@peerbit/any-store";
+import { logger as loggerFn } from "@peerbit/logger";
 import PQueue from "p-queue";
+import path from "path-browserify";
 import { v4 as uuid } from "uuid";
 import { Entry } from "./entry.js";
-import { type AnyStore } from "@peerbit/any-store";
-import { variant, option, field, vec } from "@dao-xyz/borsh";
-import { serialize, deserialize } from "@dao-xyz/borsh";
-import { logger as loggerFn } from "@peerbit/logger";
 
-import path from "path-browserify";
 export const logger = loggerFn({ module: "heads-cache" });
-export class CachedValue { }
+export class CachedValue {}
 /* export type AppendOptions<T> = {
 	signers?: ((data: Uint8Array) => Promise<SignatureWithKey>)[];
 	nexts?: Entry<T>[];
@@ -60,23 +66,23 @@ const updateHashes = async (
 	headsPath: string,
 	lastCid: string | undefined,
 	lastCounter: bigint,
-	hashes: string[]
+	hashes: string[],
 ): Promise<{ counter: bigint; newPath: string }> => {
 	const newHeadsPath = path.join(
 		headsPath,
 		String(headCache.headsPathCounter),
-		uuid()
+		uuid(),
 	);
 	const counter = lastCounter + BigInt(hashes.length);
 	await Promise.all([
 		headCache.cache?.put(
 			headsPath,
-			serialize(new CachePath(newHeadsPath.toString()))
+			serialize(new CachePath(newHeadsPath.toString())),
 		),
 		headCache.cache?.put(
 			newHeadsPath,
-			serialize(new HeadsCacheToSerialize(hashes, counter, lastCid))
-		)
+			serialize(new HeadsCacheToSerialize(hashes, counter, lastCid)),
+		),
 	]);
 	return { counter, newPath: newHeadsPath };
 };
@@ -153,7 +159,7 @@ export class HeadsCache<T> /* implements Initiable<T>  */ {
 			added?: (Entry<T> | string)[];
 			removed?: (Entry<T> | string)[];
 		},
-		reset?: boolean
+		reset?: boolean,
 	) {
 		if (typeof reset !== "boolean" && change.added) {
 			// Only reset all heads if loaded once, since we don't want too loose track of unloaded heads
@@ -190,7 +196,7 @@ export class HeadsCache<T> /* implements Initiable<T>  */ {
 				this.headsPath,
 				this._lastHeadsPath,
 				this._lastHeadsCount,
-				change.added.map((x) => (typeof x === "string" ? x : x.hash))
+				change.added.map((x) => (typeof x === "string" ? x : x.hash)),
 			);
 			this._lastHeadsPath = update.newPath;
 			this._lastHeadsCount = update.counter;
@@ -204,7 +210,7 @@ export class HeadsCache<T> /* implements Initiable<T>  */ {
 					this.removedHeadsPath,
 					this._lastRemovedHeadsPath,
 					this._lastRemovedHeadsCount,
-					change.removed.map((x) => (typeof x === "string" ? x : x.hash))
+					change.removed.map((x) => (typeof x === "string" ? x : x.hash)),
 				);
 				this._lastRemovedHeadsPath = update.newPath;
 				this._lastRemovedHeadsCount = update.counter;
@@ -216,11 +222,11 @@ export class HeadsCache<T> /* implements Initiable<T>  */ {
 				) {
 					const resetToHeads = await this.getCachedHeads(
 						this._lastHeadsPath,
-						this._lastRemovedHeadsPath
+						this._lastRemovedHeadsPath,
 					);
 					await this._updateCachedHeads(
 						{ added: resetToHeads, removed: [] },
-						true
+						true,
 					);
 				}
 			}
@@ -236,14 +242,14 @@ export class HeadsCache<T> /* implements Initiable<T>  */ {
 
 	async getCachedHeads(
 		lastHeadsPath: string | undefined = this._lastHeadsPath,
-		lastRemovedHeadsPath: string | undefined = this._lastRemovedHeadsPath
+		lastRemovedHeadsPath: string | undefined = this._lastRemovedHeadsPath,
 	): Promise<string[]> {
 		if (!this._cache) {
 			return [];
 		}
 		const getHashes = async (
 			start: string | undefined,
-			filter?: Set<string>
+			filter?: Set<string>,
 		) => {
 			const result: string[] = [];
 			let next = start;
@@ -253,7 +259,7 @@ export class HeadsCache<T> /* implements Initiable<T>  */ {
 				const cache = bytes && deserialize(bytes, HeadsCacheToSerialize);
 				next = cache?.last;
 				cache?.heads.forEach((head) => {
-					if (filter && filter.has(head)) {
+					if (filter?.has(head)) {
 						return;
 					}
 
@@ -385,10 +391,10 @@ export class HeadsCache<T> /* implements Initiable<T>  */ {
 			added?: (Entry<T> | string)[];
 			removed?: (Entry<T> | string)[];
 		},
-		reset?: boolean
+		reset?: boolean,
 	) {
 		return this._cacheWriteQueue?.add(() =>
-			this._updateCachedHeads(changes, reset)
+			this._updateCachedHeads(changes, reset),
 		);
 	}
 }