@blamejs/blamejs-shop 0.2.15 → 0.2.17

package/lib/vendor/blamejs/lib/cache.js

@@ -331,6 +331,25 @@ function _memoryBackend(cfg) {
     return true;
   }
 
+  // Atomic read-modify-write. Single-process V8 is single-threaded and the
+  // read + mutatorFn decision run with no `await` before the write, so no
+  // concurrent task can interleave between reading the current value and
+  // committing the new one. Same contract as the cluster backend's update.
+  async function _updateEntry(key, mutatorFn, expiresAt, meta) {
+    var now = clock();
+    var entry = entries.get(key);
+    var current = (entry && !_isExpired(entry, now)) ? entry.value : null;
+    var decision = mutatorFn(current);
+    if (decision && decision.abort !== undefined) return { aborted: decision.abort };
+    if (decision && decision.delete === true) {
+      if (entry) { _untrack(key, entry); entries.delete(key); }
+      return { updated: true, deleted: true };
+    }
+    var effExpires = (decision.expiresAt !== undefined) ? decision.expiresAt : expiresAt;
+    await set(key, decision.value, effExpires, meta);
+    return { updated: true, value: decision.value };
+  }
+
   async function has(key) {
     var entry = entries.get(key);
     if (!entry) return false;
@@ -420,6 +439,7 @@ function _memoryBackend(cfg) {
     name:           "memory",
     get:            get,
     set:            set,
+    update:         _updateEntry,
     del:            del,
     has:            has,
     clear:          clear,
@@ -511,32 +531,109 @@ function _clusterBackend(cfg) {
     var storedExpires = (expiresAt === Infinity) ? Number.MAX_SAFE_INTEGER : expiresAt;
     var now = clock();
     var ck = _composedKey(key);
-    // SQLite + Postgres both honor ON CONFLICT (cacheKey) DO UPDATE.
-    await clusterStorage.execute(
-      "INSERT INTO _blamejs_cache (cacheKey, valueJson, expiresAt, updatedAt) " +
-      "VALUES (?, ?, ?, ?) " +
-      "ON CONFLICT (cacheKey) DO UPDATE SET " +
-      "valueJson = ?, expiresAt = ?, updatedAt = ?",
-      [ck, json, storedExpires, now, json, storedExpires, now]
-    );
-    // Tag handling: drop any prior tags for this key (tags can change
-    // across sets), then INSERT the new ones. The PRIMARY KEY on
-    // (cacheKey, tag) makes the INSERT idempotent if duplicate tags
-    // sneak in.
     var tags = meta && Array.isArray(meta.tags) ? meta.tags : null;
-    await clusterStorage.execute(
-      "DELETE FROM _blamejs_cache_tags WHERE cacheKey = ?",
-      [ck]
-    );
-    if (tags && tags.length > 0) {
-      for (var i = 0; i < tags.length; i++) {
-        await clusterStorage.execute(
-          "INSERT INTO _blamejs_cache_tags (cacheKey, tag) VALUES (?, ?) " +
-          "ON CONFLICT (cacheKey, tag) DO NOTHING",
-          [ck, tags[i]]
-        );
+    // The value UPSERT and the tag-index rewrite (DELETE prior tags, then
+    // INSERT the new set) must commit as ONE unit. Done as separate
+    // statements they race: two concurrent set()s on the same key can
+    // interleave their DELETE/INSERT pairs, leaving a tag index that no
+    // longer matches the value row — so a later invalidateTag misses the
+    // key (a stale, possibly authorization-bearing, value survives a wipe).
+    // Wrapping them in a transaction makes a concurrent set see either the
+    // whole prior state or the whole new state, never a mix.
+    // SQLite + Postgres both honor ON CONFLICT (cacheKey) DO UPDATE.
+    await clusterStorage.transaction(async function (tx) {
+      await tx.execute(
+        "INSERT INTO _blamejs_cache (cacheKey, valueJson, expiresAt, updatedAt) " +
+        "VALUES (?, ?, ?, ?) " +
+        "ON CONFLICT (cacheKey) DO UPDATE SET " +
+        "valueJson = ?, expiresAt = ?, updatedAt = ?",
+        [ck, json, storedExpires, now, json, storedExpires, now]
+      );
+      // Drop any prior tags for this key (tags can change across sets),
+      // then INSERT the new ones. The PRIMARY KEY on (cacheKey, tag) makes
+      // the INSERT idempotent if duplicate tags sneak in.
+      await tx.execute(
+        "DELETE FROM _blamejs_cache_tags WHERE cacheKey = ?",
+        [ck]
+      );
+      if (tags && tags.length > 0) {
+        for (var i = 0; i < tags.length; i++) {
+          await tx.execute(
+            "INSERT INTO _blamejs_cache_tags (cacheKey, tag) VALUES (?, ?) " +
+            "ON CONFLICT (cacheKey, tag) DO NOTHING",
+            [ck, tags[i]]
+          );
+        }
       }
+    });
+  }
+
+  // Atomic read-modify-write. Reads the current value, calls mutatorFn,
+  // and commits the result in one transaction — with a compare-and-set
+  // (UPDATE ... WHERE valueJson = <the exact bytes we read>) so a
+  // concurrent writer on another node cannot clobber the change (lost
+  // update). On a CAS miss the whole thing retries against the fresh
+  // value. Single-node serializes via clusterStorage.transaction, so the
+  // CAS never misses there; the retry only fires in cluster mode.
+  // mutatorFn(current|null) returns { value } to commit, { abort: data }
+  // to leave the row untouched and surface `data`, or { delete: true }.
+  async function _updateRow(key, mutatorFn, expiresAt, meta) {
+    var ck = _composedKey(key);
+    var maxRetries = 5;
+    for (var attempt = 0; attempt < maxRetries; attempt++) {
+      var outcome = await clusterStorage.transaction(async function (tx) {
+        var now = clock();
+        var row = await tx.executeOne(
+          "SELECT valueJson, expiresAt FROM _blamejs_cache WHERE cacheKey = ?", [ck]);
+        var oldRaw = null;
+        var current = null;
+        if (row && row.expiresAt > now) {
+          oldRaw = row.valueJson;
+          var stored = row.valueJson;
+          if (typeof stored === "string" && stored.indexOf(CACHE_SEAL_PREFIX) === 0) {
+            stored = vault().unseal(stored.substring(CACHE_SEAL_PREFIX.length));
+          }
+          current = safeJson.parse(stored, { maxBytes: C.BYTES.mib(64) });
+        }
+        var decision = mutatorFn(current);
+        if (decision && decision.abort !== undefined) return { aborted: decision.abort };
+        if (decision && decision.delete === true) {
+          if (oldRaw !== null) {
+            await tx.execute("DELETE FROM _blamejs_cache WHERE cacheKey = ? AND valueJson = ?", [ck, oldRaw]);
+            await tx.execute("DELETE FROM _blamejs_cache_tags WHERE cacheKey = ?", [ck]);
+          }
+          return { updated: true, deleted: true };
+        }
+        var json = safeJson.stringify(decision.value);
+        if (meta && meta.seal === true) json = CACHE_SEAL_PREFIX + vault().seal(json);
+        // The mutator may pin the entry's expiry to the value's own
+        // lifetime (e.g. a grant whose expiresAt the mutator just read);
+        // otherwise the caller-resolved ttl applies.
+        var effExpires = (decision.expiresAt !== undefined) ? decision.expiresAt : expiresAt;
+        var storedExpires = (effExpires === Infinity) ? Number.MAX_SAFE_INTEGER : effExpires;
+        if (oldRaw === null) {
+          // Row was absent/expired — insert, but lose the race if another
+          // writer inserted concurrently (ON CONFLICT DO NOTHING → 0 rows).
+          var ins = await tx.execute(
+            "INSERT INTO _blamejs_cache (cacheKey, valueJson, expiresAt, updatedAt) " +
+            "VALUES (?, ?, ?, ?) ON CONFLICT (cacheKey) DO NOTHING",
+            [ck, json, storedExpires, now]);
+          if (!ins || ins.rowCount !== 1) return { conflict: true };
+        } else {
+          // CAS: only commit if the row still holds the exact bytes we read.
+          var upd = await tx.execute(
+            "UPDATE _blamejs_cache SET valueJson = ?, expiresAt = ?, updatedAt = ? " +
+            "WHERE cacheKey = ? AND valueJson = ?",
+            [json, storedExpires, now, ck, oldRaw]);
+          if (!upd || upd.rowCount !== 1) return { conflict: true };
+        }
+        return { updated: true, value: decision.value };
+      });
+      if (outcome && outcome.conflict) continue;   // value moved under us — retry
+      return outcome;
     }
+    throw _err("UPDATE_CONTENTION",
+      "cache.update: exceeded " + maxRetries + " retries under write contention for key");
   }
 
   async function del(key) {
@@ -672,6 +769,7 @@ function _clusterBackend(cfg) {
     name:           "cluster",
     get:            get,
     set:            set,
+    update:         _updateRow,
     del:            del,
     has:            has,
     clear:          clear,
@@ -1014,6 +1112,68 @@ function create(opts) {
     emitObs("cache.set", { namespace: namespace });
   }
 
+  /**
+   * @primitive b.cache.update
+   * @signature b.cache.update(key, mutatorFn, opts?)
+   * @since     0.13.39
+   * @status    stable
+   * @related   b.cache.create
+   *
+   * Atomic read-modify-write. Reads the current value, calls
+   * `mutatorFn(current | null)`, and commits the result in one operation
+   * so a concurrent writer cannot clobber the change (lost update) — the
+   * race that makes a plain `get` → mutate → `set` unsafe for counters,
+   * sets, and quorum state. The memory backend is atomic by single-thread;
+   * the cluster backend uses a transaction with compare-and-set + retry.
+   *
+   * `mutatorFn` returns one of: `{ value }` to commit the new value,
+   * `{ abort: data }` to leave the entry untouched and surface `data` to
+   * the caller, or `{ delete: true }` to remove the entry. The call
+   * resolves to `{ updated: true, value }`, `{ updated: true, deleted: true }`,
+   * or `{ aborted: data }`.
+   *
+   * @opts
+   *   ttlMs:  number | Infinity,   // lifetime of the written value; default the instance ttlMs
+   *   seal:   boolean,             // cluster backend only — seal the value at rest
+   *
+   * @example
+   *   await counters.update("hits", function (n) {
+   *     return { value: (n || 0) + 1 };
+   *   });
+   */
+  async function update(key, mutatorFn, callerOpts) {
+    _ensureOpen("update");
+    _validateKey(key, "cache.update");
+    if (typeof mutatorFn !== "function") {
+      throw _err("BAD_OPT", "cache.update: mutatorFn must be a function, got " + typeof mutatorFn);
+    }
+    if (typeof backend.update !== "function") {
+      throw _err("UNSUPPORTED",
+        "cache.update is unsupported by the '" + (backend.name || "custom") + "' backend " +
+        "(memory + cluster implement it; a custom backend must provide update for atomic RMW).");
+    }
+    var ttlMs = _resolveTtl(callerOpts, "update");
+    var expiresAt = (ttlMs === Infinity) ? Infinity : (clock() + ttlMs);
+    var seal = !!(callerOpts && callerOpts.seal === true);
+    if (seal && backend.name !== "cluster") {
+      throw _err("BAD_OPT",
+        "cache.update: seal: true is only supported on the cluster backend " +
+        "(this cache instance uses '" + (backend.name || "custom") + "').");
+    }
+    var result;
+    try { result = await backend.update(key, mutatorFn, expiresAt, { ttlMs: ttlMs, seal: seal }); }
+    catch (e) {
+      emitObs("cache.backend.failed", { namespace: namespace, op: "update" });
+      _backendFailedAudit("update", e);
+      throw e;
+    }
+    if (result && (result.updated || result.deleted)) {
+      emitObs("cache.update", { namespace: namespace });
+      if (result.deleted) { softExpiry.delete(key); _publishInvalidation({ kind: "del", key: key }); }
+    }
+    return result;
+  }
+
   async function del(key) {
     _ensureOpen("del");
     _validateKey(key, "cache.del");
@@ -1308,6 +1468,7 @@ function create(opts) {
   return {
     get:                    get,
     set:                    set,
+    update:                 update,
     del:                    del,
     has:                    has,
     clear:                  clear,

package/lib/vendor/blamejs/lib/cert.js

@@ -54,6 +54,7 @@ var atomicFile    = require("./atomic-file");
 var safeJson      = require("./safe-json");
 var { defineClass } = require("./framework-error");
 var C             = require("./constants");
+var { boot }      = require("./log");
 
 var acme          = lazyRequire(function () { return require("./acme"); });
 var vault         = lazyRequire(function () { return require("./vault"); });
@@ -62,6 +63,7 @@ var networkTls    = lazyRequire(function () { return require("./network-tls"); }
 var bCrypto       = lazyRequire(function () { return require("./crypto"); });
 
 var CertError = defineClass("CertError");
+var log = boot("cert");
 
 var DEFAULT_RENEW_INTERVAL_MS    = C.TIME.hours(6);
 var DEFAULT_MIN_DAYS_BEFORE_EXPIRY = 14;
@@ -140,8 +142,13 @@ function _createSealedDiskStorage(opts) {
       if (!nodeFs.existsSync(p)) return null;
       try { return safeJson.parse(nodeFs.readFileSync(p, "utf8"), { maxBytes: C.BYTES.kib(16) }); }
       catch (e) {
-        throw new CertError("cert/bad-meta",
-          "cert: meta.json for '" + certName + "' is corrupt: " + e.message);
+        // meta.json is a derived index (expiry + fingerprint), not a
+        // source of truth — the sealed cert is. A corrupt meta must not
+        // block renewal: treat it as absent so _ensureCert re-derives it
+        // from a fresh issue rather than throwing out of start().
+        log.warn("cert: meta.json for '" + certName + "' unreadable (" +
+          e.message + ") — treating as absent, will re-derive");
+        return null;
       }
     },
 
@@ -413,8 +420,21 @@ function create(opts) {
       ? nodeFs.readFileSync(nodePath.join(storage.rootDir, "account/jwk.json.sealed"))
       : null;
     if (sealedBuf) {
-      var plain = (opts.storage.vault || vault().getDefaultStore()).unseal(sealedBuf);
-      var jwk = safeJson.parse(plain.toString("utf8"), { maxBytes: C.BYTES.kib(64) });
+      var jwk;
+      try {
+        var plain = (opts.storage.vault || vault().getDefaultStore()).unseal(sealedBuf);
+        jwk = safeJson.parse(plain.toString("utf8"), { maxBytes: C.BYTES.kib(64) });
+      } catch (e) {
+        // The ACME account key binds existing order + authorization
+        // history, so it is NOT auto-regenerated on corruption (unlike a
+        // re-issuable cert) — that would silently abandon the account.
+        // Fail with an actionable error naming the file + recovery instead
+        // of letting a raw decrypt/parse error escape out of start().
+        throw new CertError("cert/account-key-unreadable",
+          "cert: ACME account key 'account/jwk.json.sealed' is unreadable (" +
+          e.message + "). Restore it from backup, or delete it to register " +
+          "a fresh ACME account (this abandons prior order history).");
+      }
       return _accountKeyFromJwk(jwk);
     }
     var pair = nodeCrypto.generateKeyPairSync("ec", { namedCurve: "P-256" });
@@ -555,18 +575,55 @@ function create(opts) {
   // for emergency reissue / key rollover when the existing cert is
   // structurally fine but operationally compromised (suspected key
   // disclosure, CA misissuance investigation, posture-driven rotation).
+  // A corrupt sealed cert/key is RECOVERABLE state — the CA re-issues on
+  // demand. Treat an unreadable sealed file like a missing one (log +
+  // re-issue) rather than letting a raw unseal/decrypt error escape out of
+  // start(): on a managed restart the same corrupt file is read on every
+  // boot, so throwing here is an unrecoverable crash loop, and a corrupt
+  // file must never be handled worse than an absent one (which already
+  // falls through to issue). The ACME account key is the one piece NOT
+  // auto-recovered this way — see _loadOrGenerateAccountKey.
+  async function _readSealedOrReissue(relPath, certName) {
+    try {
+      return await storage.readSealed(relPath);
+    } catch (e) {
+      log.warn("cert: sealed '" + relPath + "' unreadable (" + e.message +
+        ") — re-issuing as if absent");
+      _emitAudit("cert.sealed.corrupt", "recovered", { path: relPath, name: certName });
+      return null;
+    }
+  }
+
   async function _ensureCert(certManifest, forceIssue) {
     var meta = await storage.readMeta(certManifest.name);
-    var certBuf = await storage.readSealed(certManifest.name + "/cert.pem");
-    var keyBuf  = await storage.readSealed(certManifest.name + "/key.pem");
-    if (!forceIssue && meta && certBuf && keyBuf &&
-        meta.expiresAt > Date.now() + minDaysBeforeExpiry * C.TIME.days(1)) {
-      // Cached, not due for renewal yet.
+    var certBuf = await _readSealedOrReissue(certManifest.name + "/cert.pem", certManifest.name);
+    var keyBuf  = await _readSealedOrReissue(certManifest.name + "/key.pem", certManifest.name);
+    // Base the renewal decision on the SEALED cert's OWN notAfter, not the
+    // plaintext meta.json index. meta is a derived convenience copy; if it
+    // drifts from — or is tampered relative to — the actual cert (a far-
+    // future meta.expiresAt over an actually-expiring cert), trusting it
+    // would skip renewal and serve an expired cert. Re-derive expiry +
+    // fingerprint from the cert itself; if it won't parse, treat it as a
+    // corrupt sealed cert and re-issue (same recovery as an unreadable one).
+    var actual = null;
+    if (certBuf) {
+      try { actual = _certMeta(certBuf.toString("utf8")); }
+      catch (e) {
+        log.warn("cert: sealed cert for '" + certManifest.name + "' will not parse (" +
+          e.message + ") — re-issuing");
+        _emitAudit("cert.sealed.corrupt", "recovered",
+          { path: certManifest.name + "/cert.pem", name: certManifest.name });
+        certBuf = null;
+      }
+    }
+    if (!forceIssue && actual && certBuf && keyBuf &&
+        actual.expiresAt > Date.now() + minDaysBeforeExpiry * C.TIME.days(1)) {
+      // Cached, and the cert's own notAfter is comfortably in the future.
       loadedContexts[certManifest.name] = {
         cert:               certBuf.toString("utf8"),
         key:                keyBuf.toString("utf8"),
-        expiresAt:          meta.expiresAt,
-        fingerprintSha256:  meta.fingerprintSha256,
+        expiresAt:          actual.expiresAt,
+        fingerprintSha256:  actual.fingerprintSha256,
         sniNames:           certManifest.domains.slice(),
       };
       return loadedContexts[certManifest.name];

package/lib/vendor/blamejs/lib/cluster-storage.js

@@ -261,6 +261,33 @@ function placeholderize(sql, dialect) {
  *   );
  *   // → { rows: [ { counter: 43, row_hash: "..." } ], rowCount: 1 }
  */
+// Single-node transaction serialization. node:sqlite is synchronous and
+// the framework shares ONE local connection, so a SQLite transaction is
+// connection-global: any statement that runs between this connection's
+// BEGIN and COMMIT lands INSIDE the transaction. `_activeTx` is a promise
+// held for the duration of a single-node transaction(); execute() waits it
+// out before running so a concurrent statement can't interleave into the
+// open transaction on the shared connection. It is null in cluster mode
+// (the pool gives each transaction its own connection, so the DB enforces
+// isolation and no global lock is needed).
+var _activeTx = null;
+
+// Raw local exec — synchronous, no transaction-lock wait. Used by execute()
+// AFTER the lock wait and by transaction() for its own statements (which
+// must NOT wait on the lock they themselves hold). Because node:sqlite is
+// synchronous this runs atomically to completion with no interleaving.
+function _localExec(sql, params) {
+  var stmt = _localDb().prepare(sql);
+  // Heuristic: if the statement returns rows (SELECT or has RETURNING),
+  // use .all(); otherwise .run() and report changes as rowCount.
+  if (/^\s*SELECT\b/i.test(sql) || /\bRETURNING\b/i.test(sql)) {
+    var rows = stmt.all.apply(stmt, params || []);
+    return { rows: rows, rowCount: rows.length };
+  }
+  var info = stmt.run.apply(stmt, params || []);
+  return { rows: [], rowCount: info.changes };
+}
+
 async function execute(sql, params) {
   if (typeof sql !== "string") {
     throw new ClusterStorageError("sql must be a string", "cluster-storage/bad-arg");
@@ -275,17 +302,93 @@ async function execute(sql, params) {
     return result;
   }
 
-  // Local SQLite path. node:sqlite is sync — wrap in a resolved Promise
-  // so callers always see the same shape regardless of mode.
-  var stmt = _localDb().prepare(sql);
-  // Heuristic: if the statement returns rows (SELECT or has RETURNING),
-  // use .all(); otherwise .run() and report changes as rowCount.
-  if (/^\s*SELECT\b/i.test(sql) || /\bRETURNING\b/i.test(sql)) {
-    var rows = stmt.all.apply(stmt, params);
-    return { rows: rows, rowCount: rows.length };
+  // Local SQLite path. Wait out any open single-node transaction so this
+  // statement can't interleave into it on the shared connection. The loop
+  // re-checks after each wait (a new transaction may have started while we
+  // waited); once it exits, `_localExec` runs synchronously to completion,
+  // so no transaction can begin between the check and the statement.
+  while (_activeTx) { try { await _activeTx; } catch (_e) { /* tx failed — proceed */ } }
+  return _localExec(sql, params);
+}
+
+/**
+ * @primitive b.clusterStorage.transaction
+ * @signature b.clusterStorage.transaction(fn)
+ * @since     0.13.38
+ * @status    stable
+ * @related   b.clusterStorage.execute
+ *
+ * Run `fn` inside an atomic transaction against the active backend, so a
+ * multi-statement read-modify-write commits all-or-nothing. `fn` receives a
+ * transaction handle exposing the same `execute` / `executeOne` /
+ * `executeAll` surface as the module — but scoped to the open transaction.
+ * Use the handle's methods inside `fn`; calling the module-level
+ * `b.clusterStorage.execute` from within `fn` would deadlock single-node
+ * (it waits for the very transaction `fn` is running).
+ *
+ * Cluster mode dispatches to the external DB's transaction (its own pooled
+ * connection + deadlock retry). Single-node serializes against other
+ * transactions and against `execute` on the shared SQLite connection.
+ *
+ * @example
+ *   await b.clusterStorage.transaction(async function (tx) {
+ *     var row = await tx.executeOne("SELECT v FROM t WHERE k = ?", ["x"]);
+ *     await tx.execute("UPDATE t SET v = ? WHERE k = ?", [row.v + 1, "x"]);
+ *   });
+ */
+async function transaction(fn) {
+  if (typeof fn !== "function") {
+    throw new ClusterStorageError("transaction requires a function", "cluster-storage/bad-arg");
+  }
+
+  if (cluster.isClusterMode()) {
+    var dialect = cluster.dialect();
+    return await externalDb.transaction(async function (txClient) {
+      function txExec(sql, params) {
+        var translated = placeholderize(resolveTables(sql), dialect);
+        return txClient.query(translated, params || []);
+      }
+      var txHandle = {
+        execute:    txExec,
+        executeOne: async function (sql, params) {
+          var r = await txExec(sql, params); return r.rows.length > 0 ? r.rows[0] : null;
+        },
+        executeAll: async function (sql, params) {
+          var r = await txExec(sql, params); return r.rows;
+        },
+      };
+      return await fn(txHandle);
+    }, { backend: cluster.externalDbBackend() });
+  }
+
+  // Single-node: serialize this transaction behind any other open one, then
+  // hold `_activeTx` so concurrent execute()/transaction() calls wait.
+  while (_activeTx) { try { await _activeTx; } catch (_e) { /* prior tx failed */ } }
+  var releaseTx;
+  _activeTx = new Promise(function (resolve) { releaseTx = resolve; });
+  function txExecLocal(sql, params) { return Promise.resolve(_localExec(sql, params)); }
+  var localHandle = {
+    execute:    txExecLocal,
+    executeOne: async function (sql, params) {
+      var r = await txExecLocal(sql, params); return r.rows.length > 0 ? r.rows[0] : null;
+    },
+    executeAll: async function (sql, params) {
+      var r = await txExecLocal(sql, params); return r.rows;
+    },
+  };
+  try {
+    _localExec("BEGIN", []);
+    try {
+      var result = await fn(localHandle);
+      _localExec("COMMIT", []);
+      return result;
+    } catch (e) {
+      try { _localExec("ROLLBACK", []); } catch (_e) { /* already errored */ }
+      throw e;
+    }
+  } finally {
+    var r = releaseTx; _activeTx = null; r();
   }
-  var info = stmt.run.apply(stmt, params);
-  return { rows: [], rowCount: info.changes };
 }
 
 // Convenience wrappers for the two common patterns.
@@ -344,6 +447,7 @@ module.exports = {
   execute:               execute,
   executeOne:            executeOne,
   executeAll:            executeAll,
+  transaction:           transaction,
   tableName:             tableName,
   resolveTables:         resolveTables,
   placeholderize:        placeholderize,