@converse/skeletor 3.1.2 → 3.1.3

package/CHANGES.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 3.1.3 (2026-06-23)
+
+- Fix a regression (since 3.1.0) where a missing record on a `read` was treated as an error.
+  `model.fetch({ promise: true })` rejected with the bare string `'Record Not Found'` on a
+  first-run read of a non-existent record (and the `error` callback / `'error'` event fired),
+  where previously 3.0.x had resolved. A read miss is a normal empty state, so it now
+  resolves with `null` on both the callback (`success`) and promise forms.
+
+  **Behaviour change:** a read miss no longer fires the `error` callback or the `'error'` event,
+  it fires `success(null)` instead.
+
+- Storage-layer `sync` failures now surface a real `Error` (with a stack) through the `error`
+  callback / rejected promise instead of a bare string. The internal `Model#hydrate`
+  `'Record Not Found'` string-match workaround is removed accordingly.
+
 ## 3.1.2 (2026-06-22)
 
 - Fix the published package missing its `dist/` directory. `dist/` is gitignored and nothing built

package/dist/skeletor.esm.js

@@ -8705,7 +8705,7 @@ class PersistentStorage {
         // eslint-disable-next-line @typescript-eslint/no-this-alias
         const that = this;
         async function localSync(method, model, options) {
-            let resp, errorMessage, promise, new_attributes;
+            let resp, caughtError, promise, new_attributes;
             // We get the collection (and if necessary the model attribute.
             // Waiting for storeInitialized will cause another iteration of
             // the event loop, after which the collection reference will
@@ -8762,10 +8762,12 @@ class PersistentStorage {
             catch (error) {
                 const storageSize = await that.getStorageSize();
                 if (error.code === 22 && storageSize === 0) {
-                    errorMessage = 'Private browsing is unsupported';
+                    caughtError = new Error('Private browsing is unsupported');
                 }
                 else {
-                    errorMessage = error.message;
+                    // Preserve a real Error (stack/name); wrap anything else so the
+                    // error path always surfaces an Error, never a bare string.
+                    caughtError = error instanceof Error ? error : new Error(error?.message ?? String(error));
                 }
             }
             if (resp) {
@@ -8779,10 +8781,21 @@ class PersistentStorage {
                     options.success(data, options);
                 }
             }
+            else if (method === 'read' && !caughtError) {
+                // A read that finds no record is a normal empty result (first run /
+                // empty storage), not an error. Resolve with `null` so the callback
+                // and promise forms of fetch() agree and a first-run read never
+                // rejects.
+                if (options && options.success) {
+                    options.success(null, options);
+                }
+            }
             else {
-                errorMessage = errorMessage ? errorMessage : 'Record Not Found';
+                // A genuine failure (storage threw, or a write produced no result):
+                // surface a real Error so consumers get a stack and `instanceof Error`
+                // holds.
                 if (options && options.error) {
-                    options.error(errorMessage);
+                    options.error(caughtError ?? new Error('Record Not Found'));
                 }
             }
         }
@@ -11454,12 +11467,6 @@ _Model_computedCache = new WeakMap(), _Model_computedDefs = new WeakMap(), _Mode
     try {
         await this.fetch({ fromStorage: true, promise: true });
     }
-    catch (e) {
-        // 'Record Not Found' is a normal first-run state (nothing stored yet);
-        // keep the initial attributes and resolve. Re-throw anything else.
-        if (e !== 'Record Not Found')
-            throw e;
-    }
     finally {
         __classPrivateFieldSet(this, _Model_state, 'ready', "f");
     }
@@ -12234,8 +12241,9 @@ class Collection extends EventEmitterObject {
 }
 _Collection_instances = new WeakSet(), _Collection_hydrate = async function _Collection_hydrate() {
     ensureUnloadListener(PersistentStorage);
-    // findAll() returns [] for an empty store, so a first-run collection
-    // resolves rather than erroring the way a model fetch-by-id would.
+    // An empty store is a normal first-run state: findAll() returns [] and a
+    // missing model record resolves to null, so hydration resolves rather
+    // than rejecting.
     await this.fetch({ fromStorage: true, promise: true });
 }, _a = Symbol.iterator;
 // This "enum" defines the three possible kinds of values which can be emitted