@pbvision/firestore-orm 0.0.23 → 0.0.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pbvision/firestore-orm",
-  "version": "0.0.23",
+  "version": "0.0.24",
   "description": "Firestore ORM Library",
   "license": "Apache-2.0",
   "type": "module",

package/src/context.js

@@ -14,6 +14,7 @@ import {
   WriteAttemptedInReadOnlyTxError,
   ModelTrackedTwiceError,
   ModelAlreadyExistsError,
+  TransactionExpiredError,
   TransactionLockTimeoutError
 } from './errors.js'
 import { Key } from './key.js'
@@ -644,6 +645,22 @@ function parseFirestoreError (err) {
       return new TransactionLockTimeoutError(err.message, err)
     }
 
+    // error 3 is INVALID_ARGUMENT, which mostly means the caller got something
+    // wrong and must NOT be retried (bad field value, malformed query). The one
+    // exception is "The referenced transaction has expired or is no longer
+    // valid": the transaction outlived Firestore's limit before this call
+    // reached the server, which happens when the client library's own retries
+    // push a slow call past the window. That says nothing about the work being
+    // wrong, only that this attempt ran out of time, so a fresh transaction is
+    // expected to succeed. Left unclassified it was non-retryable, so a
+    // transient slowdown surfaced to callers as a hard failure. Match on the
+    // message, never on the code alone, so genuine INVALID_ARGUMENT bugs still
+    // fail fast.
+    if (err.code === 3 &&
+        /transaction has expired or is no longer valid/i.test(err.message)) {
+      return new TransactionExpiredError(err.message, err)
+    }
+
     // error 6 is if you try to create a model that already exists
     if (err.code === 6) {
       // if we can't parse out the doc id, then still throw this error but the

package/src/errors.js

@@ -70,6 +70,23 @@ export class TransactionLockTimeoutError extends TransactionFailedError {
   }
 }
 
+/**
+ * Thrown when Firestore rejects an operation because the transaction it names
+ * is no longer valid, i.e. the transaction outlived Firestore's limit before
+ * this call reached the server. Like a lock timeout this says nothing about the
+ * work being wrong, only that this attempt ran out of time, so a fresh attempt
+ * is expected to succeed and it is retryable.
+ *
+ * @memberof Errors
+ */
+export class TransactionExpiredError extends TransactionFailedError {
+  constructor (reason, original) {
+    super(reason, original)
+    this.name = this.constructor.name
+    this.retryable = true
+  }
+}
+
 /**
  * Thrown when there's some error with a particular model.
  * @memberof Errors