@peerbit/log 3.0.34 → 4.0.0-55cebfe

package/src/entry-with-refs.ts

@@ -1,4 +1,4 @@
-import { Entry } from "./entry.js";
+import type { Entry } from "./entry.js";
 
 export interface EntryWithRefs<T> {
 	entry: Entry<T>;

package/src/entry.ts

@@ -1,35 +1,35 @@
-import { HLC, LamportClock as Clock, Timestamp } from "./clock.js";
 import {
-	variant,
-	field,
-	serialize,
 	deserialize,
+	field,
+	fixedArray,
 	option,
+	serialize,
+	variant,
 	vec,
-	fixedArray,
-	BinaryWriter,
-	serializer
 } 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,
-	Identity,
-	X25519Keypair
+	sha256Base64,
 } from "@peerbit/crypto";
 import { verify } from "@peerbit/crypto";
-import { compare, equals } from "@peerbit/uint8arrays";
-import { Encoding, NO_ENCODING } from "./encoding.js";
+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 { Blocks } from "@peerbit/blocks-interface";
-import { Keychain } from "@peerbit/keychain";
+import { equals } from "./utils.js";
 
 export type MaybeEncryptionPublicKey =
 	| X25519PublicKey
@@ -120,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);
@@ -135,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;
@@ -155,27 +155,25 @@ export class Meta {
 	@field({ type: option(Uint8Array) })
 	data?: Uint8Array; // Optional metadata
 
-	constructor(properties?: {
+	constructor(properties: {
 		gid: string;
 		clock: Clock;
 		type: EntryType;
 		data?: Uint8Array;
 		next: string[];
 	}) {
-		if (properties) {
-			this.gid = properties.gid;
-			this.clock = properties.clock;
-			this.type = properties.type;
-			this.data = properties.data;
-			this.next = properties.next;
-		}
+		this.gid = properties.gid;
+		this.clock = properties.clock;
+		this.type = properties.type;
+		this.data = properties.data;
+		this.next = properties.next;
 	}
 }
 
 @variant(0)
 export class Signatures {
 	@field({ type: vec(MaybeEncrypted) })
-	signatures: MaybeEncrypted<SignatureWithKey>[];
+	signatures!: MaybeEncrypted<SignatureWithKey>[];
 
 	constructor(properties?: { signatures: MaybeEncrypted<SignatureWithKey>[] }) {
 		if (properties) {
@@ -199,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)
@@ -212,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>
@@ -250,7 +263,7 @@ export class Entry<T>
 	_signatures?: Signatures;
 
 	@field({ type: option("string") }) // we do option because we serialize and store this in a block without the hash, to receive the hash, which we later set
-	hash: string; // "zd...Foo", we'll set the hash after persisting the entry
+	hash!: string; // "zd...Foo", we'll set the hash after persisting the entry
 
 	createdLocally?: boolean;
 
@@ -278,8 +291,8 @@ export class Entry<T>
 					keychain?: Keychain;
 					encoding: Encoding<T>;
 			  }
-			| Entry<T>
-	): Entry<T> {
+			| Entry<T>,
+	): this {
 		if (props instanceof Entry) {
 			this._keychain = props._keychain;
 			this._encoding = props._encoding;
@@ -355,7 +368,7 @@ export class Entry<T>
 		return (await this.getMeta()).next;
 	}
 
-	private _size: number;
+	private _size!: number;
 
 	set size(number: number) {
 		this._size = number;
@@ -364,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;
@@ -376,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) {
@@ -394,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") {
@@ -435,7 +449,7 @@ export class Entry<T>
 			payload: entry._payload,
 			reserved: entry._reserved,
 			signatures: undefined,
-			hash: undefined
+			hash: undefined,
 		});
 		return trimmed;
 	}
@@ -480,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) {
@@ -495,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,
 			};
 		}
 
@@ -515,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;
@@ -530,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;
@@ -546,7 +560,7 @@ export class Entry<T>
 						"Expecting next(s) to happen before entry, got: " +
 							n.meta.clock.timestamp +
 							" > " +
-							cv.timestamp
+							cv.timestamp,
 					);
 				}
 			}
@@ -559,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) {
@@ -588,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
@@ -605,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?.[
+				: (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))) {
@@ -657,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,
+			}),
+		});
 	}
 
 	/**
@@ -685,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);
 	}
 
 	/**
@@ -699,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);
@@ -743,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
 	}
 
 	/**
@@ -755,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,12 +1,18 @@
+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";
-import { 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 { Entry } from "./entry.js";
 
-import path from "path-browserify";
 export const logger = loggerFn({ module: "heads-cache" });
 export class CachedValue {}
 /* export type AppendOptions<T> = {
@@ -32,10 +38,8 @@ export class UnsfinishedReplication {
 	@field({ type: vec("string") })
 	hashes: string[];
 
-	constructor(opts?: { hashes: string[] }) {
-		if (opts) {
-			this.hashes = opts.hashes;
-		}
+	constructor(opts: { hashes: string[] }) {
+		this.hashes = opts.hashes;
 	}
 }
 
@@ -62,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 };
 };
@@ -90,9 +94,9 @@ interface HeadsIndex {
 }
 export class HeadsCache<T> /* implements Initiable<T>  */ {
 	// An access controller that is note part of the store manifest, usefull for circular store -> access controller -> store structures
-	headsPath: string;
-	removedHeadsPath: string;
-	initialized: boolean;
+	headsPath!: string;
+	removedHeadsPath!: string;
+	initialized: boolean = false;
 
 	private _headsPathCounter = 0;
 
@@ -106,7 +110,7 @@ export class HeadsCache<T> /* implements Initiable<T>  */ {
 	private _cacheWriteQueue?: PQueue<any, any>;
 
 	private _loaded = false;
-	private _index: HeadsIndex;
+	private _index!: HeadsIndex;
 
 	constructor(index: HeadsIndex) {
 		this._index = index;
@@ -155,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
@@ -192,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;
@@ -206,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;
@@ -218,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,
 					);
 				}
 			}
@@ -238,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;
@@ -255,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;
 					}
 
@@ -387,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),
 		);
 	}
 }