indexeddbshim 17.3.1 → 17.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "indexeddbshim",
-  "version": "17.3.1",
+  "version": "17.3.2",
   "type": "module",
   "author": "Parashuram <code@nparashuram.com>",
   "contributors": [
@@ -102,6 +102,7 @@
     "w3c-test": "run-s clean-w3c test-and-start:w3c",
     "w3c-good-only": "NODE_OPTIONS=--max_old_space_size=16384 node test-support/node-idb-test.js good",
     "w3c-bad-only": "NODE_OPTIONS=--max_old_space_size=16384 node test-support/node-idb-test.js bad",
+    "w3c-good-worker-only": "NODE_OPTIONS=--max_old_space_size=16384 node test-support/node-idb-test.js good-worker",
     "w3c-good": "run-s w3c-build w3c-good-only clean-w3c",
     "w3c-bad": "run-s w3c-build w3c-bad-only clean-w3c",
     "w3c-good-test": "run-s w3c-good-only clean-w3c",
@@ -171,7 +172,7 @@
     "eventtargeter": "0.12.0",
     "sync-promise-expanded": "^2.0.0",
     "typeson": "10.2.0",
-    "typeson-registry": "14.2.1",
+    "typeson-registry": "14.2.2",
     "websql-configurable": "^3.0.6"
   },
   "devDependencies": {

package/src/IDBObjectStore.js

@@ -6,6 +6,7 @@ import DOMStringList from './DOMStringList.js';
 import * as util from './util.js';
 import * as Key from './Key.js';
 import {executeFetchIndexData, buildFetchIndexDataSQL, IDBIndex} from './IDBIndex.js';
+import cmp from './cmp.js';
 import IDBTransaction from './IDBTransaction.js';
 import * as Sca from './Sca.js';
 import CFG from './CFG.js';
@@ -69,6 +70,11 @@ const IDBObjectStoreAlias = IDBObjectStore;
  *     success: (key: import('./Key.js').Key, cn?: Integer) => void,
  *     failCb: import('./Key.js').SQLFailureCallback
  *   ) => void,
+ *   __checkIndexConstraints: (
+ *     tx: WebSQLTransaction,
+ *     value: import('./Key.js').Value,
+ *     excludeKey: import('./Key.js').Key|Integer|undefined
+ *   ) => SyncPromise,
  *   __insertData: (
  *     tx: WebSQLTransaction,
  *     encoded: string,
@@ -518,6 +524,77 @@ IDBObjectStore.prototype.__deriveKey = function (tx, value, key, success, failCb
     }
 };
 
+/**
+ * Validates `value`'s unique index entries against the table's *current*
+ *   state without mutating anything -- used by `__storingRecordObjectStore`
+ *   to check a `put()`'s constraints *before* `__overwrite` deletes the
+ *   existing row for that key, so a rejected `put()` can't end up losing
+ *   the record it was trying to replace (see
+ *   `idbobjectstore-put-unique-index-constraint-is-atomic.any.js`).
+ *   `excludeKey`, when given, treats a conflicting record as a non-conflict
+ *   if it's the very record being overwritten (its own current entry would
+ *   otherwise self-conflict on every no-op `put()` of an unchanged value).
+ *   `__insertData` below still runs its own (now redundant, but harmless --
+ *   the old row is gone by then) equivalent check as its first step; this
+ *   isn't merged into it because `__insertData` also performs the actual
+ *   `INSERT`, which cannot safely run before `__overwrite`'s `DELETE` when
+ *   overwriting an existing key.
+ * @param {WebSQLTransaction} tx
+ * @param {import('./Key.js').Value} value
+ * @param {import('./Key.js').Key|Integer|undefined} excludeKey
+ * @this {IDBObjectStoreFull}
+ * @returns {SyncPromise}
+ */
+IDBObjectStore.prototype.__checkIndexConstraints = function (tx, value, excludeKey) {
+    const me = this;
+    const indexPromises = Object.keys(me.__indexes).map((indexName) => {
+        return new SyncPromise((resolve, reject) => {
+            const index = me.__indexes[indexName];
+            if (index.__pendingCreate || index.__deleted || !index.unique) {
+                resolve(undefined);
+                return;
+            }
+            /**
+             * @type {import('./Key.js').KeyValueObject|
+             *   import('./Key.js').KeyPathEvaluateValue}
+             */
+            let indexKey;
+            try {
+                indexKey = Key.extractKeyValueDecodedFromValueUsingKeyPath(value, index.keyPath, index.multiEntry);
+                if (
+                    ('invalid' in indexKey && indexKey.invalid) ||
+                    ('failure' in indexKey && indexKey.failure)
+                ) {
+                    throw new Error('Go to catch');
+                }
+            } catch (err) {
+                resolve(undefined);
+                return;
+            }
+            indexKey = indexKey.value;
+            if (indexKey === undefined) {
+                resolve(undefined);
+                return;
+            }
+            const multiCheck = index.multiEntry && Array.isArray(indexKey);
+            const fetchArgs = buildFetchIndexDataSQL(true, index, indexKey, 'key', multiCheck);
+            executeFetchIndexData(null, ...fetchArgs, tx, null, function success (key) {
+                if (key === undefined || (excludeKey !== undefined && cmp(key, excludeKey) === 0)) {
+                    resolve(undefined);
+                    return;
+                }
+                reject(createDOMException(
+                    'ConstraintError',
+                    'Index already contains a record equal to ' +
+                        (multiCheck ? 'one of the subkeys of' : '') +
+                        '`indexKey`'
+                ));
+            }, reject);
+        });
+    });
+    return SyncPromise.all(indexPromises);
+};
+
 /**
  *
  * @param {WebSQLTransaction} tx
@@ -794,7 +871,32 @@ IDBObjectStore.__storingRecordObjectStore = function (request, store, invalidate
                     }, error);
                 }
                 if (!noOverwrite) {
-                    store.__overwrite(tx, clonedKeyOrCurrentNumber, insert, error);
+                    // Validate unique index constraints *before* `__overwrite`
+                    //   deletes the existing row at this key -- otherwise a
+                    //   `put()` that ends up rejected still permanently loses
+                    //   the record it was trying to replace (see
+                    //   `idbobjectstore-put-unique-index-constraint-is-atomic.any.js`).
+                    store.__checkIndexConstraints(tx, value, clonedKeyOrCurrentNumber).then(() => {
+                        store.__overwrite(tx, clonedKeyOrCurrentNumber, insert, error);
+                        return undefined;
+                    /**
+                     * @param {Error|DOMException} err
+                     * @returns {null}
+                     */
+                    }).catch(function (err) {
+                        /**
+                         * @returns {void}
+                         */
+                        function fail () {
+                            error(err);
+                        }
+                        if (typeof oldCn === 'number') {
+                            Key.assignCurrentNumber(tx, store, oldCn, fail, fail);
+                            return null;
+                        }
+                        fail();
+                        return null;
+                    });
                     return;
                 }
                 insert(tx);

package/src/IDBRecord.js

@@ -77,6 +77,14 @@ readonlyProperties.forEach((prop) => {
          * @returns {import('./Key.js').Key|import('./Key.js').Value}
          */
         get [prop] () {
+            // This is defined on the *shared* prototype (see above), so,
+            //   unlike a per-instance getter, it's reachable by calling it
+            //   directly on `IDBRecord.prototype` itself (not a real
+            //   instance) -- WebIDL requires that to throw.
+            if (!(this instanceof IDBRecordAlias)) {
+                throw new TypeError('Illegal invocation');
+            }
+            // @ts-ignore `this` is a real instance past the check above (not an issue in TS7)
             return this['__' + prop];
         }
     };