@peerbit/blocks 2.0.32 → 2.1.0-55cebfe

package/package.json

@@ -1,65 +1,89 @@
 {
-	"name": "@peerbit/blocks",
-	"version": "2.0.32",
-	"description": "Block store streaming",
-	"type": "module",
-	"sideEffects": false,
-	"private": false,
-	"publishConfig": {
-		"access": "public"
-	},
-	"module": "lib/esm/index.js",
-	"types": "lib/esm/index.d.ts",
-	"exports": {
-		"import": "./lib/esm/index.js"
-	},
-	"scripts": {
-		"clean": "shx rm -rf lib/*",
-		"build": "yarn clean && tsc -p tsconfig.json",
-		"test": "node ../../../node_modules/.bin/jest test  -c  ../../../jest.config.ts --runInBand --forceExit",
-		"test:unit": "node ../../../node_modules/.bin/jest test  -c  ../../../jest.config.unit.ts --runInBand --forceExit",
-		"test:integration": "node ../node_modules/.bin/jest test -c  ../../../jest.config.integration.ts --runInBand --forceExit"
-	},
-	"files": [
-		"lib",
-		"src",
-		"!src/**/__tests__",
-		"!lib/**/__tests__",
-		"!src/**/__benchmark__",
-		"!lib/**/__benchmark__",
-		"LICENSE"
-	],
-	"engines": {
-		"node": ">=16.15.1"
-	},
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/dao-xyz/peerbit.git"
-	},
-	"keywords": [
-		"peerbit"
-	],
-	"author": "dao.xyz",
-	"license": "MIT",
-	"bugs": {
-		"url": "https://github.com/dao-xyz/peerbit/issues"
-	},
-	"homepage": "https://github.com/dao-xyz/peerbit#readme",
-	"localMaintainers": [
-		"dao.xyz"
-	],
-	"devDependencies": {
-		"@peerbit/libp2p-test-utils": "2.1.3"
-	},
-	"dependencies": {
-		"@dao-xyz/borsh": "^5.2.1",
-		"@ipld/dag-cbor": "^9.0.2",
-		"@peerbit/any-store": "^2.0.2",
-		"@peerbit/blocks-interface": "1.2.19",
-		"@peerbit/crypto": "2.2.0",
-		"@peerbit/stream": "4.0.5",
-		"libp2p": "^1.2.3",
-		"multiformats": "^13.0.1"
-	},
-	"gitHead": "fcd486b9a5c3b7d94e2ae14f1b06ab2a0f7841ad"
+  "name": "@peerbit/blocks",
+  "version": "2.1.0-55cebfe",
+  "description": "Block store streaming",
+  "type": "module",
+  "types": "./dist/src/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "*": [
+        "*",
+        "dist/*",
+        "dist/src/*",
+        "dist/src/*/index"
+      ],
+      "src/*": [
+        "*",
+        "dist/*",
+        "dist/src/*",
+        "dist/src/*/index"
+      ]
+    }
+  },
+  "files": [
+    "src",
+    "dist",
+    "!dist/e2e",
+    "!dist/test",
+    "!**/*.tsbuildinfo"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js"
+    }
+  },
+  "eslintConfig": {
+    "extends": "peerbit",
+    "parserOptions": {
+      "project": true,
+      "sourceType": "module"
+    },
+    "ignorePatterns": [
+      "!.aegir.js",
+      "test/ts-use",
+      "*.d.ts"
+    ]
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "clean": "aegir clean",
+    "build": "aegir build --no-bundle",
+    "test": "aegir test --target node",
+    "lint": "aegir lint"
+  },
+  "engines": {
+    "node": ">=16.15.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dao-xyz/peerbit.git"
+  },
+  "keywords": [
+    "peerbit"
+  ],
+  "author": "dao.xyz",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/dao-xyz/peerbit/issues"
+  },
+  "homepage": "https://github.com/dao-xyz/peerbit#readme",
+  "localMaintainers": [
+    "dao.xyz"
+  ],
+  "devDependencies": {
+    "@peerbit/libp2p-test-utils": "2.1.4-55cebfe"
+  },
+  "dependencies": {
+    "@dao-xyz/borsh": "^5.2.3",
+    "@peerbit/any-store": "2.1.0-55cebfe",
+    "@peerbit/stream": "4.0.6-55cebfe",
+    "@peerbit/blocks-interface": "1.3.0-55cebfe",
+    "@peerbit/crypto": "2.3.0-55cebfe",
+    "@ipld/dag-cbor": "^9.0.2",
+    "libp2p": "^1.8.1",
+    "multiformats": "^13.0.1"
+  }
 }

package/src/any-blockstore.ts

@@ -1,16 +1,17 @@
-import { Blocks } from "@peerbit/blocks-interface";
+import { type PeerId } from "@libp2p/interface";
+import { createStore } from "@peerbit/any-store";
+import { type AnyStore } from "@peerbit/any-store-interface";
 import {
+	type Blocks,
 	cidifyString,
 	codecCodes,
 	createBlock,
 	defaultHasher,
-	stringifyCid
-} from "./block.js";
-import { decode, type Block } from "multiformats/block";
+	stringifyCid,
+} from "@peerbit/blocks-interface";
+import { type PublicSignKey } from "@peerbit/crypto";
 import { waitFor } from "@peerbit/time";
-import { PeerId } from "@libp2p/interface";
-import { PublicSignKey } from "@peerbit/crypto";
-import { AnyStore, createStore } from "@peerbit/any-store";
+import { type Block, decode } from "multiformats/block";
 
 export class AnyBlockStore implements Blocks {
 	private _store: AnyStore;
@@ -28,7 +29,7 @@ export class AnyBlockStore implements Blocks {
 			links?: string[];
 			timeout?: number;
 			hasher?: any;
-		}
+		},
 	): Promise<Uint8Array | undefined> {
 		const cidObject = cidifyString(cid);
 		try {
@@ -36,11 +37,11 @@ export class AnyBlockStore implements Blocks {
 			if (!bytes) {
 				return undefined;
 			}
-			const codec = codecCodes[cidObject.code];
+			const codec = (codecCodes as any)[cidObject.code];
 			const block = await decode({
 				bytes,
 				codec,
-				hasher: options?.hasher || defaultHasher
+				hasher: options?.hasher || defaultHasher,
 			});
 			return (block as Block<Uint8Array, any, any, any>).bytes;
 		} catch (error: any) {
@@ -86,8 +87,8 @@ export class AnyBlockStore implements Blocks {
 				{
 					delayInterval: 100,
 					timeout: 10 * 1000,
-					signal: this._closeController.signal
-				}
+					signal: this._closeController.signal,
+				},
 			);
 			await this._opening;
 		} finally {
@@ -96,7 +97,7 @@ export class AnyBlockStore implements Blocks {
 	}
 
 	async stop(): Promise<void> {
-		this._onClose && this._onClose();
+		this._onClose?.();
 		this._closeController?.abort();
 		return this._store.close();
 	}
@@ -105,10 +106,14 @@ export class AnyBlockStore implements Blocks {
 		return this._store.status();
 	}
 	async waitFor(peer: PeerId | PublicSignKey): Promise<void> {
-		return; // Offline storage // TODO this feels off resolving
+		// Offline storage // TODO this feels off resolving
 	}
 
 	async size() {
 		return this._store.size();
 	}
+
+	persisted(): boolean | Promise<boolean> {
+		return this._store.persisted();
+	}
 }

package/src/index.ts

@@ -1,9 +1,3 @@
-export {
-	cidifyString,
-	stringifyCid,
-	createBlock,
-	getBlockValue
-} from "./block.js";
 export { DirectBlock } from "./libp2p.js";
 export * from "./interface.js";
 export * from "./any-blockstore.js";

package/src/interface.ts

@@ -1,5 +1,5 @@
-import { MaybePromise } from "@peerbit/any-store";
-import { Blocks as IBlockStore } from "@peerbit/blocks-interface";
+import type { MaybePromise } from "@peerbit/any-store-interface";
+import type { Blocks as IBlockStore } from "@peerbit/blocks-interface";
 
 export type StoreStatus = MaybePromise<
 	"open" | "opening" | "closed" | "closing"

package/src/libp2p.ts

@@ -1,14 +1,12 @@
-import { BlockStore } from "./interface.js";
-import { Blocks as IBlocks } from "@peerbit/blocks-interface";
+import { deserialize, serialize } from "@dao-xyz/borsh";
+import { createStore } from "@peerbit/any-store";
+import type { GetOptions, Blocks as IBlocks } from "@peerbit/blocks-interface";
+import { type PublicSignKey } from "@peerbit/crypto";
 import { DirectStream } from "@peerbit/stream";
-import { DirectStreamComponents } from "@peerbit/stream";
+import { type DirectStreamComponents } from "@peerbit/stream";
+import { AnyWhere, type DataMessage } from "@peerbit/stream-interface";
 import { AnyBlockStore } from "./any-blockstore.js";
-import { GetOptions } from "@peerbit/blocks-interface";
-import { createStore } from "@peerbit/any-store";
 import { BlockMessage, RemoteBlocks } from "./remote.js";
-import { PublicSignKey } from "@peerbit/crypto";
-import { AnyWhere, DataMessage } from "@peerbit/stream-interface";
-import { deserialize, serialize } from "@dao-xyz/borsh";
 
 export type DirectBlockComponents = DirectStreamComponents;
 
@@ -24,15 +22,15 @@ export class DirectBlock extends DirectStream implements IBlocks {
 			canRelayMessage?: boolean;
 			localTimeout?: number;
 			messageProcessingConcurrency?: number;
-		}
+		},
 	) {
 		super(components, ["/lazyblock/0.0.0"], {
 			messageProcessingConcurrency: options?.messageProcessingConcurrency || 10,
 			canRelayMessage: options?.canRelayMessage ?? true,
 			connectionManager: {
 				dialer: false,
-				pruner: false
-			}
+				pruner: false,
+			},
 		});
 		this.remoteBlocks = new RemoteBlocks({
 			local: new AnyBlockStore(createStore(options?.directory)),
@@ -40,14 +38,14 @@ export class DirectBlock extends DirectStream implements IBlocks {
 				this.publish(serialize(message), { mode: new AnyWhere() }),
 			localTimeout: options?.localTimeout || 1000,
 			messageProcessingConcurrency: options?.messageProcessingConcurrency || 10,
-			waitFor: this.waitFor.bind(this)
+			waitFor: this.waitFor.bind(this),
 		});
 
 		this.onDataFn = (data: CustomEvent<DataMessage>) => {
 			data.detail?.data?.length &&
 				data.detail?.data.length > 0 &&
 				this.remoteBlocks.onMessage(
-					deserialize(data.detail.data!, BlockMessage)
+					deserialize(data.detail.data!, BlockMessage),
 				);
 		};
 		this.onPeerConnectedFn = (evt: CustomEvent<PublicSignKey>) =>
@@ -63,7 +61,7 @@ export class DirectBlock extends DirectStream implements IBlocks {
 	}
 	async get(
 		cid: string,
-		options?: GetOptions | undefined
+		options?: GetOptions | undefined,
 	): Promise<Uint8Array | undefined> {
 		return this.remoteBlocks.get(cid, options);
 	}
@@ -98,4 +96,8 @@ export class DirectBlock extends DirectStream implements IBlocks {
 	get status() {
 		return this.remoteBlocks?.status || this.started;
 	}
+
+	persisted(): boolean | Promise<boolean> {
+		return this.remoteBlocks.persisted();
+	}
 }

package/src/remote.ts

@@ -1,21 +1,24 @@
-import { BlockStore } from "./interface.js";
-import { Blocks as IBlocks } from "@peerbit/blocks-interface";
+import { field, variant } from "@dao-xyz/borsh";
+import type { PeerId } from "@libp2p/interface";
+import { CustomEvent, TypedEventEmitter } from "@libp2p/interface";
 import {
-	stringifyCid,
+	type GetOptions,
+	type Blocks as IBlocks,
+	checkDecodeBlock,
 	cidifyString,
 	codecCodes,
-	checkDecodeBlock
-} from "./block.js";
-import { variant, field } from "@dao-xyz/borsh";
+	stringifyCid,
+} from "@peerbit/blocks-interface";
+import { PublicSignKey } from "@peerbit/crypto";
+import { logger as loggerFn } from "@peerbit/logger";
+import { AbortError } from "@peerbit/time";
 import { CID } from "multiformats";
 import { type Block } from "multiformats/block";
-import { PublicSignKey } from "@peerbit/crypto";
-import { AnyBlockStore } from "./any-blockstore.js";
-import { GetOptions } from "@peerbit/blocks-interface";
 import PQueue from "p-queue";
-import { AbortError } from "@peerbit/time";
-import type { PeerId } from "@libp2p/interface";
-import { TypedEventEmitter, CustomEvent } from "@libp2p/interface";
+import { AnyBlockStore } from "./any-blockstore.js";
+import type { BlockStore } from "./interface.js";
+
+export const logger = loggerFn({ module: "blocks-remote" });
 
 export class BlockMessage {}
 
@@ -68,14 +71,14 @@ export class RemoteBlocks implements IBlocks {
 			messageProcessingConcurrency?: number;
 			publish: (
 				message: BlockRequest | BlockResponse,
-				options?: { to?: string[] }
+				options?: { to?: string[] },
 			) => Promise<Uint8Array | void>;
 			waitFor(peer: PeerId | PublicSignKey): Promise<void>;
-		}
+		},
 	) {
 		const localTimeout = options?.localTimeout || 1000;
 		this._loadFetchQueue = new PQueue({
-			concurrency: options?.messageProcessingConcurrency || 10
+			concurrency: options?.messageProcessingConcurrency || 10,
 		});
 		this.localStore = options?.local;
 		this._resolvers = new Map();
@@ -85,7 +88,7 @@ export class RemoteBlocks implements IBlocks {
 			try {
 				if (message instanceof BlockRequest && this.localStore) {
 					this._loadFetchQueue.add(() =>
-						this.handleFetchRequest(message, localTimeout)
+						this.handleFetchRequest(message, localTimeout),
 					);
 				} else if (message instanceof BlockResponse) {
 					// TODO make sure we are not storing too much bytes in ram (like filter large blocks)
@@ -93,8 +96,8 @@ export class RemoteBlocks implements IBlocks {
 					this._resolvers.get(message.cid)?.(message.bytes);
 				}
 			} catch (error) {
-				console.error("Got error for libp2p block transport: ", error);
-				return; // timeout o r invalid cid
+				logger.error("Got error for libp2p block transport: ", error);
+				// timeout o r invalid cid
 			}
 		};
 	}
@@ -111,7 +114,7 @@ export class RemoteBlocks implements IBlocks {
 	}
 	async get(
 		cid: string,
-		options?: GetOptions | undefined
+		options?: GetOptions | undefined,
 	): Promise<Uint8Array | undefined> {
 		const cidObject = cidifyString(cid);
 		let value = this.localStore
@@ -150,17 +153,17 @@ export class RemoteBlocks implements IBlocks {
 	}
 	onReachable(publicKey: PublicSignKey) {
 		this._events.dispatchEvent(
-			new CustomEvent("peer:reachable", { detail: publicKey })
+			new CustomEvent("peer:reachable", { detail: publicKey }),
 		);
 	}
 
 	private async handleFetchRequest(
 		request: BlockRequest,
-		localTimeout: number
+		localTimeout: number,
 	) {
 		const cid = stringifyCid(request.cid);
 		const bytes = await this.localStore.get(cid, {
-			timeout: localTimeout
+			timeout: localTimeout,
 		});
 		if (!bytes) {
 			return;
@@ -171,9 +174,14 @@ export class RemoteBlocks implements IBlocks {
 	private async _readFromPeers(
 		cidString: string,
 		cidObject: CID,
-		options: { timeout?: number; hasher?: any; from?: string[] } = {}
+		options: {
+			signal?: AbortSignal;
+			timeout?: number;
+			hasher?: any;
+			from?: string[];
+		} = {},
 	): Promise<Uint8Array | undefined> {
-		const codec = codecCodes[cidObject.code];
+		const codec = (codecCodes as any)[cidObject.code];
 		let promise = this._readFromPeersPromises.get(cidString);
 		if (!promise) {
 			promise = new Promise<Block<any, any, any, 1> | undefined>(
@@ -182,41 +190,46 @@ export class RemoteBlocks implements IBlocks {
 						() => {
 							resolve(undefined);
 						},
-						options.timeout || 30 * 1000
+						options.timeout || 30 * 1000,
 					);
 					const abortHandler = () => {
 						clearTimeout(timeoutCallback);
 						this._resolvers.delete(cidString);
 						this.closeController.signal.removeEventListener(
 							"abort",
-							abortHandler
+							abortHandler,
 						);
+						options?.signal?.removeEventListener("abort", abortHandler);
 						reject(new AbortError());
 					};
 					this.closeController.signal.addEventListener("abort", abortHandler);
+					options?.signal?.addEventListener("abort", abortHandler);
 
 					this._resolvers.set(cidString, async (bytes: Uint8Array) => {
 						const value = await checkDecodeBlock(cidObject, bytes, {
 							codec,
-							hasher: options?.hasher
+							hasher: options?.hasher,
 						});
 
 						clearTimeout(timeoutCallback);
 						this._resolvers.delete(cidString); // TODO concurrency might not work as expected here
 						this.closeController.signal.removeEventListener(
 							"abort",
-							abortHandler
+							abortHandler,
 						);
 						resolve(value);
 					});
-				}
+				},
 			);
 
 			this._readFromPeersPromises.set(cidString, promise);
 
 			const publish = (to: string) => {
-				if (!options?.from || options.from.includes(to))
-					this.options.publish(new BlockRequest(cidString), { to: [to] });
+				if (!options?.from || options.from.includes(to)) {
+					return this.options.publish(new BlockRequest(cidString), {
+						to: [to],
+					});
+				}
 			};
 
 			const publishOnNewPeers = (e: CustomEvent<PublicSignKey>) => {
@@ -224,7 +237,7 @@ export class RemoteBlocks implements IBlocks {
 			};
 			this._events.addEventListener("peer:reachable", publishOnNewPeers);
 			this.options.publish(new BlockRequest(cidString), {
-				to: options.from
+				to: options.from,
 			});
 
 			// we want to make sure that if some new peers join, we also try to ask them
@@ -270,4 +283,8 @@ export class RemoteBlocks implements IBlocks {
 			return "closed";
 		}
 	}
+
+	persisted(): boolean | Promise<boolean> {
+		return this.localStore?.persisted() || false;
+	}
 }