@peerbit/native-backbone 0.1.1 → 0.1.3

package/src/error.rs

@@ -0,0 +1,244 @@
+use peerbit_indexer_core::persistence::DecodeError;
+use peerbit_indexer_core::schema::SchemaError;
+use peerbit_indexer_core::wire::WireError;
+use peerbit_log_rust::LogError;
+use peerbit_shared_log_rust::SharedLogError;
+use wasm_bindgen::JsValue;
+
+/// Error type for the native backbone core. Every failure path in the core
+/// modules reports one of these variants instead of constructing a
+/// `JsValue`, so the crate can be consumed as a plain rlib on non-wasm
+/// targets without aborting the process. The `Display` output reproduces
+/// the exact message strings historically thrown across the wasm boundary.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum BackboneError {
+    Expected(&'static str),
+    ExpectedArray(&'static str),
+    ExpectedString(&'static str),
+    ExpectedBoolean(&'static str),
+    ExpectedNumber(&'static str),
+    ExpectedBytes(&'static str),
+    ExpectedU64String(&'static str),
+    ExpectedStringArray,
+    ExpectedBytesArray,
+    ExpectedUnsignedIntegerArray,
+    MismatchedInputLengths(&'static str),
+    MismatchedCompactCoordinateFacts(&'static str),
+    MustBeNumber(&'static str),
+    MustBeArray(&'static str),
+    MissingOrInvalid(&'static str),
+    HashDigestTooShortU32,
+    HashDigestTooShortU64,
+    ResolutionMustBeU32OrU64,
+    ExpectedReservedBytes,
+    WireSyncStashFrameTaken,
+    WireSyncPinnedEntryMissing,
+    CoordinateCountOverflow,
+    Truncated(&'static str),
+    InvalidBool(&'static str),
+    InvalidProjectionOptionMarker,
+    UnsupportedDocumentProjectionFieldType,
+    UnsupportedProjectedDocumentFieldType,
+    ProjectionValueOutputTypeMismatch,
+    DocumentProjectionPlanLengthMismatch,
+    ProjectionPlanLengthMismatch,
+    TrailingDocumentSignerFactBytes,
+    MissingDocumentVariant,
+    InvalidDocumentVariant,
+    DocumentVariantMismatch,
+    UnsupportedDocumentVariantType,
+    MissingOutputVariant,
+    InvalidOutputVariant,
+    UnsupportedOutputVariantType,
+    UnsupportedContextProjectionSource,
+    UnsupportedProjectionSourceKind,
+    PlainPutPayloadTooShort,
+    PlainPutPayloadLengthMismatch,
+    DocumentContextSuffixCapacityOverflow,
+    DocumentSchemaIrNotConfigured,
+    MissingCachedDocumentProjectionPlan,
+    MissingPlainPutPayloadForDocumentIndex,
+    MissingPlainPutPayloadForDocumentProjection,
+    MissingDocumentContextField(&'static str),
+    MaxReplicasMustBeNumber,
+    RawReceiveOriginalIndexOverflow,
+    RawReceiveSelectedIndexOverflow,
+    RawReceiveGroupIndexOverflow,
+    MissingPreparedRawReceiveEntry,
+    MismatchedPreparedRawReceiveVerifyLengths,
+    MissingPartialVerifyHashes,
+    Wire(WireError),
+    SharedLog(SharedLogError),
+    Schema(SchemaError),
+    Decode(DecodeError),
+    Log(LogError),
+    Message(String),
+}
+
+impl std::fmt::Display for BackboneError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            BackboneError::Expected(label) => write!(f, "Expected {label}"),
+            BackboneError::ExpectedArray(label) => write!(f, "Expected {label} array"),
+            BackboneError::ExpectedString(label) => write!(f, "Expected {label} string"),
+            BackboneError::ExpectedBoolean(label) => write!(f, "Expected {label} boolean"),
+            BackboneError::ExpectedNumber(label) => write!(f, "Expected {label} number"),
+            BackboneError::ExpectedBytes(label) => write!(f, "Expected {label} bytes"),
+            BackboneError::ExpectedU64String(label) => {
+                write!(f, "Expected {label} u64 string")
+            }
+            BackboneError::ExpectedStringArray => f.write_str("Expected string array"),
+            BackboneError::ExpectedBytesArray => f.write_str("Expected bytes array"),
+            BackboneError::ExpectedUnsignedIntegerArray => {
+                f.write_str("Expected unsigned integer array")
+            }
+            BackboneError::MismatchedInputLengths(label) => {
+                write!(f, "Mismatched {label} input lengths")
+            }
+            BackboneError::MismatchedCompactCoordinateFacts(label) => f.write_str(label),
+            BackboneError::MustBeNumber(label) => write!(f, "{label} must be a number"),
+            BackboneError::MustBeArray(field) => write!(f, "{field} must be an array"),
+            BackboneError::MissingOrInvalid(field) => write!(f, "Missing or invalid {field}"),
+            BackboneError::HashDigestTooShortU32 => {
+                f.write_str("hash digest must have at least 4 bytes")
+            }
+            BackboneError::HashDigestTooShortU64 => {
+                f.write_str("hash digest must have at least 8 bytes")
+            }
+            BackboneError::ResolutionMustBeU32OrU64 => f.write_str("resolution must be u32 or u64"),
+            BackboneError::ExpectedReservedBytes => f.write_str("expected 4 reserved bytes"),
+            BackboneError::WireSyncStashFrameTaken => {
+                f.write_str("wire sync stash frame already taken")
+            }
+            BackboneError::WireSyncPinnedEntryMissing => {
+                f.write_str("wire sync pinned stash entry missing")
+            }
+            BackboneError::CoordinateCountOverflow => f.write_str("Coordinate count overflow"),
+            BackboneError::Truncated(label) => write!(f, "Truncated {label}"),
+            BackboneError::InvalidBool(label) => write!(f, "Invalid bool {label}"),
+            BackboneError::InvalidProjectionOptionMarker => {
+                f.write_str("Invalid projection option marker")
+            }
+            BackboneError::UnsupportedDocumentProjectionFieldType => {
+                f.write_str("Unsupported document projection field type")
+            }
+            BackboneError::UnsupportedProjectedDocumentFieldType => {
+                f.write_str("Unsupported projected document field type")
+            }
+            BackboneError::ProjectionValueOutputTypeMismatch => {
+                f.write_str("Projection value does not match output type")
+            }
+            BackboneError::DocumentProjectionPlanLengthMismatch => {
+                f.write_str("Document projection plan length mismatch")
+            }
+            BackboneError::ProjectionPlanLengthMismatch => {
+                f.write_str("Projection plan length mismatch")
+            }
+            BackboneError::TrailingDocumentSignerFactBytes => {
+                f.write_str("Trailing document signer fact bytes")
+            }
+            BackboneError::MissingDocumentVariant => f.write_str("Missing document variant"),
+            BackboneError::InvalidDocumentVariant => f.write_str("Invalid document variant"),
+            BackboneError::DocumentVariantMismatch => f.write_str("Document variant mismatch"),
+            BackboneError::UnsupportedDocumentVariantType => {
+                f.write_str("Unsupported document variant type")
+            }
+            BackboneError::MissingOutputVariant => f.write_str("Missing output variant"),
+            BackboneError::InvalidOutputVariant => f.write_str("Invalid output variant"),
+            BackboneError::UnsupportedOutputVariantType => {
+                f.write_str("Unsupported output variant type")
+            }
+            BackboneError::UnsupportedContextProjectionSource => {
+                f.write_str("Unsupported context projection source")
+            }
+            BackboneError::UnsupportedProjectionSourceKind => {
+                f.write_str("Unsupported projection source kind")
+            }
+            BackboneError::PlainPutPayloadTooShort => f.write_str("Plain put payload is too short"),
+            BackboneError::PlainPutPayloadLengthMismatch => {
+                f.write_str("Plain put payload length mismatch")
+            }
+            BackboneError::DocumentContextSuffixCapacityOverflow => {
+                f.write_str("Document context suffix capacity overflow")
+            }
+            BackboneError::DocumentSchemaIrNotConfigured => {
+                f.write_str("Native backbone document schema IR has not been configured")
+            }
+            BackboneError::MissingCachedDocumentProjectionPlan => {
+                f.write_str("Missing cached document projection plan")
+            }
+            BackboneError::MissingPlainPutPayloadForDocumentIndex => {
+                f.write_str("Missing plain put payload for document index")
+            }
+            BackboneError::MissingPlainPutPayloadForDocumentProjection => {
+                f.write_str("Missing plain put payload for document projection")
+            }
+            BackboneError::MissingDocumentContextField(label) => {
+                write!(f, "Missing document context {label} field")
+            }
+            BackboneError::MaxReplicasMustBeNumber => f.write_str("maxReplicas must be a number"),
+            BackboneError::RawReceiveOriginalIndexOverflow => {
+                f.write_str("Raw receive original index overflow")
+            }
+            BackboneError::RawReceiveSelectedIndexOverflow => {
+                f.write_str("Raw receive selected index overflow")
+            }
+            BackboneError::RawReceiveGroupIndexOverflow => {
+                f.write_str("Raw receive group index overflow")
+            }
+            BackboneError::MissingPreparedRawReceiveEntry => {
+                f.write_str("Missing prepared raw receive entry")
+            }
+            BackboneError::MismatchedPreparedRawReceiveVerifyLengths => {
+                f.write_str("Expected equal prepared raw receive verify lengths")
+            }
+            BackboneError::MissingPartialVerifyHashes => {
+                f.write_str("Missing partial verify hashes")
+            }
+            BackboneError::Wire(error) => write!(f, "{error}"),
+            BackboneError::SharedLog(error) => write!(f, "{error}"),
+            BackboneError::Schema(error) => write!(f, "{error}"),
+            BackboneError::Decode(error) => write!(f, "{error}"),
+            BackboneError::Log(error) => write!(f, "{error}"),
+            BackboneError::Message(message) => f.write_str(message),
+        }
+    }
+}
+
+impl std::error::Error for BackboneError {}
+
+impl From<WireError> for BackboneError {
+    fn from(error: WireError) -> Self {
+        BackboneError::Wire(error)
+    }
+}
+
+impl From<SchemaError> for BackboneError {
+    fn from(error: SchemaError) -> Self {
+        BackboneError::Schema(error)
+    }
+}
+
+impl From<DecodeError> for BackboneError {
+    fn from(error: DecodeError) -> Self {
+        BackboneError::Decode(error)
+    }
+}
+
+impl From<LogError> for BackboneError {
+    fn from(error: LogError) -> Self {
+        BackboneError::Log(error)
+    }
+}
+
+impl From<SharedLogError> for BackboneError {
+    fn from(error: SharedLogError) -> Self {
+        BackboneError::SharedLog(error)
+    }
+}
+
+impl From<BackboneError> for JsValue {
+    fn from(error: BackboneError) -> Self {
+        JsValue::from_str(&error.to_string())
+    }
+}

package/src/index.ts

@@ -2116,6 +2116,7 @@ type WasmModule = {
 
 let wasmModulePromise: Promise<WasmModule> | undefined;
 let wasmInitialized = false;
+let wasmInitPromise: Promise<void> | undefined;
 
 const loadWasm = async (): Promise<WasmModule> => {
 	if (!wasmModulePromise) {
@@ -2127,28 +2128,31 @@ const loadWasm = async (): Promise<WasmModule> => {
 
 	const wasm = await wasmModulePromise;
 	if (!wasmInitialized) {
-		const processLike = (
-			globalThis as { process?: { versions?: { node?: string } } }
-		).process;
-		if (processLike?.versions?.node) {
-			const fsPromises = "fs/promises";
-			const { readFile } = (await import(
-				/* @vite-ignore */ fsPromises
-			)) as typeof import("fs/promises");
-			const bytes = await readFile(
-				new URL("../wasm/native_backbone_bg.wasm", import.meta.url),
-			);
-			wasm.initSync({ module: bytes });
-		} else {
-			await wasm.default({
-				module_or_path: new URL(
-					"../wasm/native_backbone_bg.wasm",
-					import.meta.url,
-				),
-			});
-		}
-		wasmInitialized = true;
+		wasmInitPromise ??= (async () => {
+			const processLike = (
+				globalThis as { process?: { versions?: { node?: string } } }
+			).process;
+			if (processLike?.versions?.node) {
+				const fsPromises = "fs/promises";
+				const { readFile } = (await import(
+					/* @vite-ignore */ fsPromises
+				)) as typeof import("fs/promises");
+				const bytes = await readFile(
+					new URL("../wasm/native_backbone_bg.wasm", import.meta.url),
+				);
+				wasm.initSync({ module: bytes });
+			} else {
+				await wasm.default({
+					module_or_path: new URL(
+						"../wasm/native_backbone_bg.wasm",
+						import.meta.url,
+					),
+				});
+			}
+			wasmInitialized = true;
+		})();
 	}
+	await wasmInitPromise;
 
 	return wasm;
 };