@logbrew/sdk 0.1.21 → 0.1.23

package/core.cjs

@@ -334,14 +334,7 @@ class LogBrewClient {
     this.eventStore = resolvedEventStore;
     let recovered;
     try {
-      recovered = loadStoredEvents({
-        batchPrefixBytes: this.batchPrefixBytes,
-        batchSuffixBytes: this.batchSuffixBytes,
-        eventStore: resolvedEventStore,
-        maxBatchBytes,
-        maxQueueBytes,
-        maxQueueSize
-      });
+      recovered = loadStoredEvents(this);
     } catch (error) {
       if (ownsEventStore) {
         try {
@@ -822,6 +815,7 @@ class LogBrewClient {
   }
 
   async #flushSnapshot(transport) {
+    this.#synchronizeEventStore();
     let remainingEvents = this.events.length;
     if (remainingEvents === 0) {
       return { statusCode: 204, attempts: 0, batches: 0 };
@@ -851,6 +845,17 @@ class LogBrewClient {
     return { statusCode, attempts, batches };
   }
 
+  #synchronizeEventStore() {
+    if (!this.eventStore) return;
+    const recovered = loadStoredEvents(this);
+    if (!isOrderedSubsequence(this.serializedEvents, recovered.serializedEvents))
+      throw new SdkError("persistence_error", "event store lost a queued record");
+    this.events = recovered.events;
+    this.serializedEvents = recovered.serializedEvents;
+    this.serializedEventBytes = recovered.serializedEventBytes;
+    this.queuedEventBytes = recovered.queuedEventBytes;
+  }
+
   #nextBatch(maxEvents) {
     let bodyBytes = this.batchPrefixBytes + this.batchSuffixBytes;
     let eventsCount = 0;
@@ -1194,6 +1199,19 @@ function loadStoredEvents({
   return { events, queuedEventBytes, serializedEventBytes, serializedEvents };
 }
 
+function isOrderedSubsequence(expected, actual) {
+  let index = 0;
+  for (const value of actual) {
+    index += value === expected[index] ? 1 : 0;
+  }
+  return index === expected.length;
+}
+
+function structuralJson(value) {
+  return JSON.stringify(value, (_, entry) => entry && !Array.isArray(entry) && typeof entry === "object"
+    ? Object.fromEntries(Object.entries(entry).sort(([left], [right]) => left.localeCompare(right))) : entry);
+}
+
 function normalizeStoredRecord(record) {
   try {
     if (!record || Array.isArray(record) || typeof record !== "object") {
@@ -1215,11 +1233,14 @@ function normalizeStoredRecord(record) {
     if (JSON.stringify(event) !== serializedEvent || utf8ByteLength(serializedEvent) !== eventBytes) {
       throw invalidStoredRecord();
     }
-    const context = event.attributes.context;
+    const recoveredAttributes = event.type === "issue" && event.attributes.level === "fatal"
+      ? { ...event.attributes, level: "critical" }
+      : event.attributes;
+    const context = recoveredAttributes.context;
     const recoveredEvent = context && !Array.isArray(context) && typeof context === "object"
       && context.schemaVersion === undefined
-      ? { ...event, attributes: { ...event.attributes, context: { schemaVersion: 1, ...context } } }
-      : event;
+      ? { ...event, attributes: { ...recoveredAttributes, context: { schemaVersion: 1, ...context } } }
+      : { ...event, attributes: recoveredAttributes };
     const normalizedEvent = {
       type: recoveredEvent.type,
       id: recoveredEvent.id,
@@ -1227,7 +1248,7 @@ function normalizeStoredRecord(record) {
       attributes: validator(recoveredEvent.attributes)
     };
     const normalizedSerializedEvent = JSON.stringify(normalizedEvent);
-    if (normalizedSerializedEvent !== JSON.stringify(recoveredEvent)) {
+    if (structuralJson(normalizedEvent) !== structuralJson(recoveredEvent)) {
       throw invalidStoredRecord();
     }
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logbrew/sdk",
-  "version": "0.1.21",
+  "version": "0.1.23",
   "description": "Public LogBrew JavaScript SDK for building, validating, and flushing event batches.",
   "type": "module",
   "main": "./index.cjs",