indexeddbshim 17.3.0 → 17.3.2

package/dist/setGlobalVars.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setGlobalVars.d.ts","sourceRoot":"","sources":["../src/setGlobalVars.js"],"names":[],"mappings":";;uBAkBa,GAAG;+BAKL,OAAO,UAAU,EAAE,iBAAiB,GAC1C,OAAO,CAAC,OAAO,UAAU,EAAE,YAAY,CAAC,QAClC,QAAQ;wBAoCN,CACR,IAAI,EAAE,OAAO,UAAU,EAAE,iBAAiB,KACvC,OAAO,UAAU,EAAE,WAAW;oCAIzB,CAAC,GAAG,EAAE;IACd,cAAc,EAAE,MAAM,CAAC;IACvB,iBAAiB,EAAE,MAAM,CAAA;CAC1B,KAAK,IAAI;4BAIA,CAAC,UAAU,GAAC,MAAM,CAAC,GAAG;IAC5B,SAAS,EAAE,MAAM,IAAI,CAAC;IACtB,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,CAAC;IAChC,WAAW,EAAE,SAAS,CAAC;IACvB,WAAW,EAAE,SAAS,CAAC;IACvB,uBAAuB,EAAE,qBAAqB,CAAC;IAC/C,0BAA0B,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;CACtD;sBAIO,MAAM;4BAIN,CAAC,OAAO,UAAU,GAAC,MAAM,CAAC,GAAG;IACrC,SAAS,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;IAChC,UAAU,EAAE,OAAO,UAAU,CAAC;IAC9B,gBAAgB,EAAE,OAAO,gBAAgB,CAAC;IAC1C,UAAU,EAAE,OAAO,UAAU,CAAC;IAC9B,kBAAkB,EAAE,OAAO,kBAAkB,CAAC;IAC9C,SAAS,EAAE,OAAO,SAAS,CAAC;IAC5B,WAAW,EAAE,OAAO,WAAW,CAAC;IAChC,cAAc,EAAE,OAAO,cAAc,CAAC;IACtC,WAAW,EAAE,OAAO,WAAW,CAAC;IAChC,aAAa,CAAC,EAAE,aAAa,CAAA;CAC9B;mCAhG+C,mBAAmB;AAwDtE;;;;GAIG;AAEH;;;;;GAKG;AAEH;;;;;;;;;GASG;AAEH;;GAEG;AAEH;;;;;;;;;;;;;GAaG;AAEH;;;;;GAKG;AACH,qCAJW,aAAa,kBACb,OAAO,CAAC,OAAO,UAAU,EAAE,YAAY,CAAC,GACtC,aAAa,CAkSzB;2BAxY8C,iBAAiB"}
+{"version":3,"file":"setGlobalVars.d.ts","sourceRoot":"","sources":["../src/setGlobalVars.js"],"names":[],"mappings":";;uBAkBa,GAAG;+BAKL,OAAO,UAAU,EAAE,iBAAiB,GAC1C,OAAO,CAAC,OAAO,UAAU,EAAE,YAAY,CAAC,QAClC,QAAQ;wBAoCN,CACR,IAAI,EAAE,OAAO,UAAU,EAAE,iBAAiB,KACvC,OAAO,UAAU,EAAE,WAAW;oCAIzB,CAAC,GAAG,EAAE;IACd,cAAc,EAAE,MAAM,CAAC;IACvB,iBAAiB,EAAE,MAAM,CAAA;CAC1B,KAAK,IAAI;4BAIA,CAAC,UAAU,GAAC,MAAM,CAAC,GAAG;IAC5B,SAAS,EAAE,MAAM,IAAI,CAAC;IACtB,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,CAAC;IAChC,WAAW,EAAE,SAAS,CAAC;IACvB,WAAW,EAAE,SAAS,CAAC;IACvB,uBAAuB,EAAE,qBAAqB,CAAC;IAC/C,0BAA0B,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;CACtD;sBAIO,MAAM;4BAIN,CAAC,OAAO,UAAU,GAAC,MAAM,CAAC,GAAG;IACrC,SAAS,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;IAChC,UAAU,EAAE,OAAO,UAAU,CAAC;IAC9B,gBAAgB,EAAE,OAAO,gBAAgB,CAAC;IAC1C,UAAU,EAAE,OAAO,UAAU,CAAC;IAC9B,kBAAkB,EAAE,OAAO,kBAAkB,CAAC;IAC9C,SAAS,EAAE,OAAO,SAAS,CAAC;IAC5B,WAAW,EAAE,OAAO,WAAW,CAAC;IAChC,cAAc,EAAE,OAAO,cAAc,CAAC;IACtC,WAAW,EAAE,OAAO,WAAW,CAAC;IAChC,aAAa,CAAC,EAAE,aAAa,CAAA;CAC9B;mCAhG+C,mBAAmB;AAwDtE;;;;GAIG;AAEH;;;;;GAKG;AAEH;;;;;;;;;GASG;AAEH;;GAEG;AAEH;;;;;;;;;;;;;GAaG;AAEH;;;;;GAKG;AACH,qCAJW,aAAa,kBACb,OAAO,CAAC,OAAO,UAAU,EAAE,YAAY,CAAC,GACtC,aAAa,CAkTzB;2BAxZ8C,iBAAiB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "indexeddbshim",
-  "version": "17.3.0",
+  "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/IDBFactory.js

@@ -668,7 +668,22 @@ IDBFactory.prototype.open = function (name /* , version */) {
                                     //   open/close the transaction's active-handler window itself.
                                     req.transaction.__handlerActive = true;
                                     req.dispatchEvent(e);
-                                    req.transaction.__handlerActive = false;
+                                    // Give any same-tick microtask scheduled from within the
+                                    //   `upgradeneeded` handler (e.g. a plain
+                                    //   `Promise.resolve().then(...)`) a chance to run -- and still
+                                    //   observe the transaction as active -- before we deactivate it
+                                    //   again, per https://github.com/w3c/IndexedDB/issues/87. Only
+                                    //   the flag reset itself is deferred here -- unlike
+                                    //   `IDBTransaction.js`'s `advanceAfterDispatch`, `finished()`
+                                    //   (this transaction's own queue-advancement/completion signal)
+                                    //   still runs synchronously, at exactly its previous timing: an
+                                    //   earlier attempt at deferring `finished()` too raced against
+                                    //   unrelated test setup that assumed a freshly deleted/created
+                                    //   database's upgrade transaction had already fully completed by
+                                    //   the time this function returns.
+                                    queueMicrotask(() => {
+                                        req.transaction.__handlerActive = false;
+                                    });
 
                                     if (e.__legacyOutputDidListenersThrowError) {
                                         logError('Error', 'An error occurred in an upgradeneeded handler attached to request chain', /** @type {Error} */ (e.__legacyOutputDidListenersThrowError)); // We do nothing else with this error as per spec

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];
         }
     };

package/src/setGlobalVars.js

@@ -274,8 +274,24 @@ function setGlobalVars (idb, initialConfig) {
                     Object.setPrototypeOf(shimIDBRequest, ShimEventTarget);
                     Object.setPrototypeOf(shimIDBTransaction, ShimEventTarget);
                     Object.setPrototypeOf(shimIDBVersionChangeEvent, ShimEvent);
-                    Object.setPrototypeOf(ShimDOMException, Error);
-                    Object.setPrototypeOf(ShimDOMException.prototype, Error.prototype);
+                    // `ShimDOMException` is the real native `DOMException` when one
+                    //   is available (see `DOMException.js`'s `useNativeDOMException`)
+                    //   -- which, unlike the shim classes above, is a single,
+                    //   process-wide singleton shared by reference across every
+                    //   sandbox this library gets installed into (see
+                    //   `node-idb-test.js`'s `sandboxObj`). A native `DOMException`
+                    //   already has the correct prototype chain out of the box
+                    //   (`Object.getPrototypeOf(DOMException) === Function.prototype`,
+                    //   not `Error`), so forcing it here isn't just unneeded but
+                    //   actively wrong -- and, because it's shared, permanently
+                    //   wrong for every later use of `DOMException` in the same
+                    //   process (e.g. a later WPT test file's own idlharness-style
+                    //   check that `DOMException` does *not* inherit from `Error`
+                    //   on the class side), not just this one shim install.
+                    if (typeof DOMException === 'undefined' || ShimDOMException !== DOMException) {
+                        Object.setPrototypeOf(ShimDOMException, Error);
+                        Object.setPrototypeOf(ShimDOMException.prototype, Error.prototype);
+                    }
                 }
                 if (IDB.indexedDB && !IDB.indexedDB.toString().includes('[native code]')) {
                     if (CFG.addNonIDBGlobals) {