interaqt 2.0.0 → 2.0.2

package/dist/drivers.js

@@ -0,0 +1,984 @@
+import m from "better-sqlite3";
+import { sqliteEncodeLiteral as N, dbConsoleLogger as g, asyncInteractionContext as l, ROW_ID_ATTR as p, defaultEncodeLiteral as S, RequireSerializableRetry as I } from "interaqt";
+import { AsyncLocalStorage as b } from "node:async_hooks";
+import { createHash as A } from "node:crypto";
+import L from "pg";
+import { PGlite as R } from "@electric-sql/pglite";
+import E from "mysql2/promise";
+let w = class {
+  constructor(e) {
+    this.db = e;
+  }
+  async setup() {
+    await this.db.scheme("CREATE Table IF NOT EXISTS _IDS_ (last INTEGER, name TEXT)"), await this.db.scheme('CREATE UNIQUE INDEX IF NOT EXISTS "_IDS__name_unique" ON _IDS_ (name)');
+  }
+  async getAutoId(e) {
+    return (await this.db.query(
+      `INSERT INTO _IDS_ (name, last) VALUES (?, 1)
+ON CONFLICT(name) DO UPDATE SET last = last + 1
+RETURNING last`,
+      [e],
+      `allocate next id for ${e}`
+    ))[0].last;
+  }
+};
+class K {
+  constructor(e = ":memory:", t) {
+    this.file = e, this.options = t, this.supportsSelectForUpdate = !1, this.maxQueryParams = 32e3, this.transactionCapability = {
+      transactions: !0,
+      isolationLevels: ["READ COMMITTED", "SERIALIZABLE"],
+      transactionBoundConnection: !1,
+      concurrentTransactions: "unsupported",
+      nestedStrategy: "reuse",
+      notes: [
+        "SQLite uses MonoStorage fallback transaction metadata for retry paths and does not provide PostgreSQL-level concurrent dispatch isolation."
+      ]
+    }, this.atomicSequenceCapability = {
+      requiresActiveTransaction: !0,
+      transactional: !0,
+      crossConnection: !1,
+      crossProcess: !1,
+      returning: !0,
+      productionSafe: !1
+    }, this.schemaDialect = {
+      name: "sqlite",
+      maxIdentifierLength: 63,
+      supportsCreateIndexIfNotExists: !0,
+      encodeLiteral: N,
+      constraints: { unique: !0, filteredUnique: !0, nonNull: !1 }
+    }, this.idSystem = new w(this), this.logger = this.options?.logger || g;
+  }
+  async open() {
+    this.db = new m(this.file, this.options), await this.idSystem.setup();
+  }
+  async openForSchemaRead() {
+    this.db = new m(this.file, this.options);
+  }
+  async setupInternalComputationState() {
+    await this.scheme(`
+CREATE TABLE IF NOT EXISTS "_ComputationState_" (
+    "key" TEXT PRIMARY KEY,
+    "numberValue" NUMERIC NULL,
+    "booleanValue" BOOLEAN NULL,
+    "stringValue" TEXT NULL,
+    "jsonValue" JSON NULL
+)`, "setup computation state table");
+  }
+  async setupScopedSequenceState() {
+    await this.scheme(`
+CREATE TABLE IF NOT EXISTS "_ScopedSequence_" (
+    "sequenceName" TEXT NOT NULL,
+    "scopeKey" TEXT NOT NULL,
+    "scope" JSON NOT NULL,
+    "lastValue" NUMERIC NOT NULL,
+    PRIMARY KEY ("sequenceName", "scopeKey")
+)`, "setup scoped sequence table");
+  }
+  async query(e, t = [], s = "") {
+    const r = l.getStore(), n = this.logger.child(r?.logContext || {}), i = t.map((o) => o === !1 ? 0 : o === !0 ? 1 : o);
+    return n.info({
+      type: "query",
+      name: s,
+      sql: e,
+      params: i
+    }), this.db.prepare(e).all(...i);
+  }
+  async update(e, t, s, r = "") {
+    const n = l.getStore(), i = this.logger.child(n?.logContext || {}), o = `${e} ${s ? `RETURNING ${s} AS id` : ""}`, a = t.map((c) => typeof c == "object" && c !== null ? JSON.stringify(c) : c === !1 ? 0 : c === !0 ? 1 : c);
+    return i.info({
+      type: "update",
+      name: r,
+      sql: o,
+      params: a
+    }), s ? this.db.prepare(o).all(...a) : this.db.prepare(o).run(...a);
+  }
+  async insert(e, t, s = "") {
+    const r = l.getStore(), n = this.logger.child(r?.logContext || {}), i = t.map((a) => typeof a == "object" && a !== null ? JSON.stringify(a) : a === !1 ? 0 : a === !0 ? 1 : a);
+    return n.info({
+      type: "insert",
+      name: s,
+      sql: e,
+      params: i
+    }), this.db.prepare(`${e} RETURNING ${p}`).all(...i)[0];
+  }
+  async delete(e, t, s = "") {
+    const r = l.getStore(), n = this.logger.child(r?.logContext || {}), i = t.map((o) => o === !1 ? 0 : o === !0 ? 1 : o);
+    return n.info({
+      type: "delete",
+      name: s,
+      sql: e,
+      params: i
+    }), this.db.prepare(e).run(...i);
+  }
+  async scheme(e, t = "") {
+    const s = l.getStore();
+    return this.logger.child(s?.logContext || {}).info({
+      type: "scheme",
+      name: t,
+      sql: e
+    }), this.db.prepare(e).run();
+  }
+  async close() {
+    this.db.close();
+  }
+  async getAutoId(e) {
+    return this.idSystem.getAutoId(e);
+  }
+  parseMatchExpression(e, t, s, r, n, i, o) {
+    if (r === "JSON" && t[0].toLowerCase() === "contains")
+      return {
+        fieldValue: `NOT NULL AND EXISTS (
+    SELECT 1
+    FROM json_each(${s})
+    WHERE json_each.value = ${o()}
+)`,
+        fieldParams: [t[1]]
+      };
+  }
+  mapToDBFieldType(e, t) {
+    return e === "pk" ? "INTEGER PRIMARY KEY" : e === "id" ? "INT" : t || e === "object" || e === "json" ? "JSON" : e === "string" ? "TEXT" : e === "boolean" ? "INT(2)" : e === "number" || e === "timestamp" ? "INT" : e;
+  }
+}
+const { Client: d, Pool: C } = L;
+let O = class {
+  constructor(e) {
+    this.db = e, this.initialized = /* @__PURE__ */ new Set(), this.recordToSequenceName = /* @__PURE__ */ new Map();
+  }
+  setup() {
+    return this.db.scheme('CREATE Table IF NOT EXISTS "_IDS_" (last INTEGER, name TEXT)');
+  }
+  sanitizeIdentifierPart(e) {
+    return (e.replace(/[^a-zA-Z0-9_]/g, "_").replace(/^_+/, "") || "record").slice(0, 32);
+  }
+  sequenceName(e) {
+    return this.sequenceNameForKey(e, e);
+  }
+  sequenceNameForKey(e, t) {
+    return `seq_${A("sha1").update(e).digest("hex").slice(0, 12)}_${this.sanitizeIdentifierPart(t)}`.slice(0, 63);
+  }
+  quoteIdentifier(e) {
+    return `"${e.replace(/"/g, '""')}"`;
+  }
+  async setupSequences(e) {
+    const t = (await this.db.query(
+      "SELECT to_regclass($1) AS exists",
+      ['"_IDS_"'],
+      "check legacy id table"
+    ))[0]?.exists, s = /* @__PURE__ */ new Map();
+    for (const r of e) {
+      const n = this.sequenceNameForKey(`${r.tableName}.${r.idField}`, r.tableName);
+      this.recordToSequenceName.set(r.recordName, n);
+      const i = this.quoteIdentifier(n);
+      await this.db.scheme(`CREATE SEQUENCE IF NOT EXISTS ${i} START WITH 1`, `create sequence ${r.recordName}`);
+      const o = await this.db.query(
+        `SELECT COALESCE(MAX("${r.idField}"), 0) AS max FROM ${this.quoteIdentifier(r.tableName)}`,
+        [],
+        `read max id for ${r.recordName}`
+      );
+      let a = 0;
+      if (t) {
+        const T = await this.db.query(
+          'SELECT COALESCE(MAX("last"), 0) AS last FROM "_IDS_" WHERE "name" = $1',
+          [r.recordName],
+          `read legacy id for ${r.recordName}`
+        );
+        a = Number(T[0]?.last ?? 0);
+      }
+      const c = Math.max(Number(o[0]?.max ?? 0), a);
+      s.set(i, Math.max(s.get(i) ?? 0, c)), this.initialized.add(r.recordName);
+    }
+    for (const [r, n] of s)
+      n >= 1 && await this.db.query(
+        `SELECT setval($1::regclass, $2, true) FROM ${r} WHERE NOT is_called OR last_value < $2`,
+        [r, n],
+        `advance sequence ${r}`
+      );
+  }
+  async getAutoId(e) {
+    if (!this.initialized.has(e))
+      throw new Error(`PostgreSQL sequence for ${e} is not initialized. Run storage setup before creating records.`);
+    const t = this.recordToSequenceName.get(e) ?? this.sequenceName(e);
+    return (await this.db.query(
+      "SELECT nextval($1::regclass) AS id",
+      [this.quoteIdentifier(t)],
+      `next id for ${e}`
+    ))[0].id;
+  }
+};
+class W {
+  constructor(e, t = {}) {
+    this.database = e, this.options = t, this.transactionContext = new b(), this.supportsSelectForUpdate = !0, this.maxQueryParams = 65e3, this.transactionCapability = {
+      transactions: !0,
+      isolationLevels: ["READ COMMITTED", "SERIALIZABLE"],
+      transactionBoundConnection: !0,
+      concurrentTransactions: "database",
+      nestedStrategy: "reuse"
+    }, this.atomicSequenceCapability = {
+      requiresActiveTransaction: !0,
+      transactional: !0,
+      crossConnection: !0,
+      crossProcess: !0,
+      returning: !0,
+      productionSafe: !0
+    }, this.schemaDialect = {
+      name: "postgres",
+      maxIdentifierLength: 63,
+      supportsCreateIndexIfNotExists: !0,
+      encodeLiteral: S,
+      constraints: { unique: !0, filteredUnique: !0, nonNull: !0 }
+    }, this.idSystem = new O(this), this.logger = this.options?.logger || g, this.db = new d({ ...t });
+  }
+  async open(e = !1) {
+    this.pool && e && (await this.pool.end(), this.pool = void 0);
+    const t = new d({
+      ...this.options
+    });
+    await t.connect(), (await t.query("SELECT FROM pg_database WHERE datname = $1", [this.database])).rows.length === 0 ? await t.query(`CREATE DATABASE "${this.database}"`) : e && (await t.query(`DROP DATABASE "${this.database}" WITH (FORCE)`), await t.query(`CREATE DATABASE "${this.database}"`)), await t.end(), this.pool || (this.pool = this.createPool(), this.db = new d({
+      ...this.options,
+      database: this.database
+    }));
+  }
+  async openForSchemaRead() {
+    this.pool || (this.pool = this.createPool(), this.db = new d({
+      ...this.options,
+      database: this.database
+    }));
+  }
+  createPool() {
+    const e = new C({
+      ...this.options,
+      database: this.database
+    });
+    return e.on("error", (t) => {
+      this.logger.error({
+        type: "pool",
+        name: "idle client error",
+        sql: "",
+        error: t instanceof Error ? t.message : String(t)
+      });
+    }), e;
+  }
+  getQueryable() {
+    const e = this.transactionContext.getStore();
+    if (e && e.depth > 0) return e.client;
+    if (!this.pool)
+      throw new Error("PostgreSQL pool is not initialized. Call open() before querying.");
+    return this.pool;
+  }
+  async runInTransaction(e, t) {
+    const s = this.transactionContext.getStore();
+    if (s && s.depth > 0) {
+      if (s.isolation !== "SERIALIZABLE" && (e.isolation ?? "READ COMMITTED") === "SERIALIZABLE")
+        throw new I(`${e.name || "nested transaction"} requires SERIALIZABLE isolation`);
+      s.depth++;
+      try {
+        return await t();
+      } finally {
+        s.depth--;
+      }
+    }
+    if (!this.pool)
+      throw new Error("PostgreSQL pool is not initialized. Call open() before starting a transaction.");
+    const r = e.isolation ?? "READ COMMITTED", n = await this.pool.connect(), i = { client: n, depth: 1, isolation: r };
+    let o = !1;
+    try {
+      await n.query(`BEGIN ISOLATION LEVEL ${r}`);
+      const a = await this.transactionContext.run(i, t);
+      return await n.query("COMMIT"), a;
+    } catch (a) {
+      try {
+        await n.query("ROLLBACK");
+      } finally {
+        n.release(), o = !0;
+      }
+      throw a;
+    } finally {
+      o || n.release();
+    }
+  }
+  async setupInternalComputationState() {
+    await this.scheme(`
+CREATE TABLE IF NOT EXISTS "_ComputationState_" (
+    "key" TEXT PRIMARY KEY,
+    "numberValue" NUMERIC NULL,
+    "booleanValue" BOOLEAN NULL,
+    "stringValue" TEXT NULL,
+    "jsonValue" JSONB NULL
+)`, "setup computation state table");
+  }
+  async setupScopedSequenceState() {
+    await this.scheme(`
+CREATE TABLE IF NOT EXISTS "_ScopedSequence_" (
+    "sequenceName" TEXT NOT NULL,
+    "scopeKey" TEXT NOT NULL,
+    "scope" JSONB NOT NULL,
+    "lastValue" NUMERIC NOT NULL,
+    PRIMARY KEY ("sequenceName", "scopeKey")
+)`, "setup scoped sequence table");
+  }
+  async query(e, t = [], s = "") {
+    const r = l.getStore(), n = this.logger.child(r?.logContext || {}), i = t;
+    return n.info({
+      type: "query",
+      name: s,
+      sql: e,
+      params: i
+    }), (await this.getQueryable().query(e, i)).rows;
+  }
+  async update(e, t, s, r = "") {
+    const n = l.getStore(), i = this.logger.child(n?.logContext || {}), o = `${e} ${s ? `RETURNING "${s}" AS id` : ""}`, a = t.map((c) => typeof c == "object" && c !== null ? JSON.stringify(c) : c);
+    return i.info({
+      type: "update",
+      name: r,
+      sql: o,
+      params: a
+    }), (await this.getQueryable().query(o, a)).rows;
+  }
+  async insert(e, t, s = "") {
+    const r = l.getStore(), n = this.logger.child(r?.logContext || {}), i = t.map((a) => typeof a == "object" && a !== null ? JSON.stringify(a) : a);
+    n.info({
+      type: "insert",
+      name: s,
+      sql: e,
+      params: i
+    });
+    const o = `${e} RETURNING "${p}"`;
+    return (await this.getQueryable().query(o, i)).rows[0];
+  }
+  async delete(e, t, s = "") {
+    const r = l.getStore(), n = this.logger.child(r?.logContext || {}), i = t;
+    return n.info({
+      type: "delete",
+      name: s,
+      sql: e,
+      params: i
+    }), (await this.getQueryable().query(e, i)).rows;
+  }
+  async scheme(e, t = "") {
+    const s = l.getStore();
+    return this.logger.child(s?.logContext || {}).info({
+      type: "scheme",
+      name: t,
+      sql: e
+    }), await this.getQueryable().query(e);
+  }
+  close() {
+    return this.pool ? this.pool.end() : this.db.end();
+  }
+  async getAutoId(e) {
+    return this.idSystem.getAutoId(e);
+  }
+  setupRecordSequences(e) {
+    return this.idSystem.setupSequences(e);
+  }
+  parseMatchExpression(e, t, s, r, n, i, o) {
+    if (r === "JSON") {
+      if (t[0].toLowerCase() === "contains") {
+        const a = s.split(".").map((c) => `"${c}"`).join(".");
+        return {
+          fieldValue: `IS NOT NULL AND ${o()} = ANY (SELECT json_array_elements_text(${a}))`,
+          fieldParams: [t[1]]
+        };
+      }
+      if (t[0] === "=" || t[0] === "!=")
+        return {
+          fieldValue: `IS NOT NULL AND ${s.split(".").map((c) => `"${c}"`).join(".")}::jsonb ${t[0]} ${o()}::jsonb`,
+          fieldParams: [JSON.stringify(t[1])]
+        };
+    }
+  }
+  getPlaceholder() {
+    let e = 0;
+    return () => (e++, `$${e}`);
+  }
+  mapToDBFieldType(e, t) {
+    return e === "pk" ? "INT GENERATED ALWAYS AS IDENTITY" : e === "id" ? "INT" : t || e === "object" ? "JSON" : e === "string" ? "TEXT" : e === "boolean" ? "BOOLEAN" : e === "number" ? "DOUBLE PRECISION" : e === "timestamp" ? "TIMESTAMP" : e;
+  }
+}
+const f = "0123456789abcdef";
+class h {
+  /** @param bytes - The 16-byte byte array representation. */
+  constructor(e) {
+    this.bytes = e;
+  }
+  /**
+   * Creates an object from the internal representation, a 16-byte byte array
+   * containing the binary UUID representation in the big-endian byte order.
+   *
+   * This method does NOT shallow-copy the argument, and thus the created object
+   * holds the reference to the underlying buffer.
+   *
+   * @throws TypeError if the length of the argument is not 16.
+   */
+  static ofInner(e) {
+    if (e.length !== 16)
+      throw new TypeError("not 128-bit length");
+    return new h(e);
+  }
+  /**
+   * Builds a byte array from UUIDv7 field values.
+   *
+   * @param unixTsMs - A 48-bit `unix_ts_ms` field value.
+   * @param randA - A 12-bit `rand_a` field value.
+   * @param randBHi - The higher 30 bits of 62-bit `rand_b` field value.
+   * @param randBLo - The lower 32 bits of 62-bit `rand_b` field value.
+   * @throws RangeError if any field value is out of the specified range.
+   */
+  static fromFieldsV7(e, t, s, r) {
+    if (!Number.isInteger(e) || !Number.isInteger(t) || !Number.isInteger(s) || !Number.isInteger(r) || e < 0 || t < 0 || s < 0 || r < 0 || e > 281474976710655 || t > 4095 || s > 1073741823 || r > 4294967295)
+      throw new RangeError("invalid field value");
+    const n = new Uint8Array(16);
+    return n[0] = e / 2 ** 40, n[1] = e / 2 ** 32, n[2] = e / 2 ** 24, n[3] = e / 2 ** 16, n[4] = e / 2 ** 8, n[5] = e, n[6] = 112 | t >>> 8, n[7] = t, n[8] = 128 | s >>> 24, n[9] = s >>> 16, n[10] = s >>> 8, n[11] = s, n[12] = r >>> 24, n[13] = r >>> 16, n[14] = r >>> 8, n[15] = r, new h(n);
+  }
+  /**
+   * Builds a byte array from a string representation.
+   *
+   * This method accepts the following formats:
+   *
+   * - 32-digit hexadecimal format without hyphens: `0189dcd553117d408db09496a2eef37b`
+   * - 8-4-4-4-12 hyphenated format: `0189dcd5-5311-7d40-8db0-9496a2eef37b`
+   * - Hyphenated format with surrounding braces: `{0189dcd5-5311-7d40-8db0-9496a2eef37b}`
+   * - RFC 9562 URN format: `urn:uuid:0189dcd5-5311-7d40-8db0-9496a2eef37b`
+   *
+   * Leading and trailing whitespaces represents an error.
+   *
+   * @throws SyntaxError if the argument could not parse as a valid UUID string.
+   */
+  static parse(e) {
+    var t, s, r, n;
+    let i;
+    switch (e.length) {
+      case 32:
+        i = (t = /^[0-9a-f]{32}$/i.exec(e)) === null || t === void 0 ? void 0 : t[0];
+        break;
+      case 36:
+        i = (s = /^([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{12})$/i.exec(e)) === null || s === void 0 ? void 0 : s.slice(1, 6).join("");
+        break;
+      case 38:
+        i = (r = /^\{([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{12})\}$/i.exec(e)) === null || r === void 0 ? void 0 : r.slice(1, 6).join("");
+        break;
+      case 45:
+        i = (n = /^urn:uuid:([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{12})$/i.exec(e)) === null || n === void 0 ? void 0 : n.slice(1, 6).join("");
+        break;
+    }
+    if (i) {
+      const o = new Uint8Array(16);
+      for (let a = 0; a < 16; a += 4) {
+        const c = parseInt(i.substring(2 * a, 2 * a + 8), 16);
+        o[a + 0] = c >>> 24, o[a + 1] = c >>> 16, o[a + 2] = c >>> 8, o[a + 3] = c;
+      }
+      return new h(o);
+    } else
+      throw new SyntaxError("could not parse UUID string");
+  }
+  /**
+   * @returns The 8-4-4-4-12 canonical hexadecimal string representation
+   * (`0189dcd5-5311-7d40-8db0-9496a2eef37b`).
+   */
+  toString() {
+    let e = "";
+    for (let t = 0; t < this.bytes.length; t++)
+      e += f.charAt(this.bytes[t] >>> 4), e += f.charAt(this.bytes[t] & 15), (t === 3 || t === 5 || t === 7 || t === 9) && (e += "-");
+    return e;
+  }
+  /**
+   * @returns The 32-digit hexadecimal representation without hyphens
+   * (`0189dcd553117d408db09496a2eef37b`).
+   */
+  toHex() {
+    let e = "";
+    for (let t = 0; t < this.bytes.length; t++)
+      e += f.charAt(this.bytes[t] >>> 4), e += f.charAt(this.bytes[t] & 15);
+    return e;
+  }
+  /** @returns The 8-4-4-4-12 canonical hexadecimal string representation. */
+  toJSON() {
+    return this.toString();
+  }
+  /**
+   * Reports the variant field value of the UUID or, if appropriate, "NIL" or
+   * "MAX".
+   *
+   * For convenience, this method reports "NIL" or "MAX" if `this` represents
+   * the Nil or Max UUID, although the Nil and Max UUIDs are technically
+   * subsumed under the variants `0b0` and `0b111`, respectively.
+   */
+  getVariant() {
+    const e = this.bytes[8] >>> 4;
+    if (e < 0)
+      throw new Error("unreachable");
+    if (e <= 7)
+      return this.bytes.every((t) => t === 0) ? "NIL" : "VAR_0";
+    if (e <= 11)
+      return "VAR_10";
+    if (e <= 13)
+      return "VAR_110";
+    if (e <= 15)
+      return this.bytes.every((t) => t === 255) ? "MAX" : "VAR_RESERVED";
+    throw new Error("unreachable");
+  }
+  /**
+   * Returns the version field value of the UUID or `undefined` if the UUID does
+   * not have the variant field value of `0b10`.
+   */
+  getVersion() {
+    return this.getVariant() === "VAR_10" ? this.bytes[6] >>> 4 : void 0;
+  }
+  /** Creates an object from `this`. */
+  clone() {
+    return new h(this.bytes.slice(0));
+  }
+  /** Returns true if `this` is equivalent to `other`. */
+  equals(e) {
+    return this.compareTo(e) === 0;
+  }
+  /**
+   * Returns a negative integer, zero, or positive integer if `this` is less
+   * than, equal to, or greater than `other`, respectively.
+   */
+  compareTo(e) {
+    for (let t = 0; t < 16; t++) {
+      const s = this.bytes[t] - e.bytes[t];
+      if (s !== 0)
+        return Math.sign(s);
+    }
+    return 0;
+  }
+}
+class q {
+  /**
+   * Creates a generator object with the default random number generator, or
+   * with the specified one if passed as an argument. The specified random
+   * number generator should be cryptographically strong and securely seeded.
+   */
+  constructor(e) {
+    this.timestamp = 0, this.counter = 0, this.random = e ?? _();
+  }
+  /**
+   * Generates a new UUIDv7 object from the current timestamp, or resets the
+   * generator upon significant timestamp rollback.
+   *
+   * This method returns a monotonically increasing UUID by reusing the previous
+   * timestamp even if the up-to-date timestamp is smaller than the immediately
+   * preceding UUID's. However, when such a clock rollback is considered
+   * significant (i.e., by more than ten seconds), this method resets the
+   * generator and returns a new UUID based on the given timestamp, breaking the
+   * increasing order of UUIDs.
+   *
+   * See {@link generateOrAbort} for the other mode of generation and
+   * {@link generateOrResetCore} for the low-level primitive.
+   */
+  generate() {
+    return this.generateOrResetCore(Date.now(), 1e4);
+  }
+  /**
+   * Generates a new UUIDv7 object from the current timestamp, or returns
+   * `undefined` upon significant timestamp rollback.
+   *
+   * This method returns a monotonically increasing UUID by reusing the previous
+   * timestamp even if the up-to-date timestamp is smaller than the immediately
+   * preceding UUID's. However, when such a clock rollback is considered
+   * significant (i.e., by more than ten seconds), this method aborts and
+   * returns `undefined` immediately.
+   *
+   * See {@link generate} for the other mode of generation and
+   * {@link generateOrAbortCore} for the low-level primitive.
+   */
+  generateOrAbort() {
+    return this.generateOrAbortCore(Date.now(), 1e4);
+  }
+  /**
+   * Generates a new UUIDv7 object from the `unixTsMs` passed, or resets the
+   * generator upon significant timestamp rollback.
+   *
+   * This method is equivalent to {@link generate} except that it takes a custom
+   * timestamp and clock rollback allowance.
+   *
+   * @param rollbackAllowance - The amount of `unixTsMs` rollback that is
+   * considered significant. A suggested value is `10_000` (milliseconds).
+   * @throws RangeError if `unixTsMs` is not a 48-bit positive integer.
+   */
+  generateOrResetCore(e, t) {
+    let s = this.generateOrAbortCore(e, t);
+    return s === void 0 && (this.timestamp = 0, s = this.generateOrAbortCore(e, t)), s;
+  }
+  /**
+   * Generates a new UUIDv7 object from the `unixTsMs` passed, or returns
+   * `undefined` upon significant timestamp rollback.
+   *
+   * This method is equivalent to {@link generateOrAbort} except that it takes a
+   * custom timestamp and clock rollback allowance.
+   *
+   * @param rollbackAllowance - The amount of `unixTsMs` rollback that is
+   * considered significant. A suggested value is `10_000` (milliseconds).
+   * @throws RangeError if `unixTsMs` is not a 48-bit positive integer.
+   */
+  generateOrAbortCore(e, t) {
+    if (!Number.isInteger(e) || e < 0 || e > 281474976710655)
+      throw new RangeError(`\`unixTsMs\` must be a 48-bit positive integer, got ${e}`);
+    if (t < 0 || t > 281474976710655)
+      throw new RangeError(`\`rollbackAllowance\` out of reasonable range, got ${t}`);
+    if (e > this.timestamp)
+      this.timestamp = e, this.resetCounter();
+    else if (e + t >= this.timestamp)
+      this.counter++, this.counter > 4398046511103 && (this.timestamp++, this.resetCounter());
+    else
+      return;
+    return h.fromFieldsV7(this.timestamp, Math.trunc(this.counter / 2 ** 30), this.counter & 2 ** 30 - 1, this.random.nextUint32());
+  }
+  /** Initializes the counter at a 42-bit random integer. */
+  resetCounter() {
+    this.counter = this.random.nextUint32() * 1024 + (this.random.nextUint32() & 1023);
+  }
+  /**
+   * Generates a new UUIDv4 object utilizing the random number generator inside.
+   *
+   * @internal
+   */
+  generateV4() {
+    const e = new Uint8Array(Uint32Array.of(this.random.nextUint32(), this.random.nextUint32(), this.random.nextUint32(), this.random.nextUint32()).buffer);
+    return e[6] = 64 | e[6] >>> 4, e[8] = 128 | e[8] >>> 2, h.ofInner(e);
+  }
+}
+const _ = () => {
+  if (typeof crypto < "u" && typeof crypto.getRandomValues < "u")
+    return new D();
+  if (typeof UUIDV7_DENY_WEAK_RNG < "u" && UUIDV7_DENY_WEAK_RNG)
+    throw new Error("no cryptographically strong RNG available");
+  return {
+    nextUint32: () => Math.trunc(Math.random() * 65536) * 65536 + Math.trunc(Math.random() * 65536)
+  };
+};
+class D {
+  constructor() {
+    this.buffer = new Uint32Array(8), this.cursor = 65535;
+  }
+  nextUint32() {
+    return this.cursor >= this.buffer.length && (crypto.getRandomValues(this.buffer), this.cursor = 0), this.buffer[this.cursor++];
+  }
+}
+let y;
+const $ = () => U().toString(), U = () => (y || (y = new q())).generate();
+let x = class {
+  constructor(e) {
+    this.db = e;
+  }
+  setup() {
+    return this.db.scheme('CREATE Table IF NOT EXISTS "_IDS_" (last INTEGER, name TEXT)');
+  }
+  async getAutoId(e) {
+    return $();
+  }
+};
+class v {
+  constructor(e, t = {}) {
+    this.database = e, this.options = t, this.supportsSelectForUpdate = !0, this.maxQueryParams = 65e3, this.transactionCapability = {
+      transactions: !0,
+      isolationLevels: ["READ COMMITTED", "SERIALIZABLE"],
+      transactionBoundConnection: !1,
+      concurrentTransactions: "unsupported",
+      nestedStrategy: "reuse",
+      notes: [
+        "PGLite uses MonoStorage fallback BEGIN/COMMIT; SERIALIZABLE is framework metadata for retry-path tests, not a production PostgreSQL isolation guarantee."
+      ]
+    }, this.atomicSequenceCapability = {
+      requiresActiveTransaction: !0,
+      transactional: !0,
+      crossConnection: !1,
+      crossProcess: !1,
+      returning: !0,
+      productionSafe: !1
+    }, this.schemaDialect = {
+      name: "postgres",
+      maxIdentifierLength: 63,
+      supportsCreateIndexIfNotExists: !0,
+      encodeLiteral: S,
+      constraints: { unique: !0, filteredUnique: !0, nonNull: !0 }
+    }, this.idSystem = new x(this), this.logger = this.options?.logger || g, this.db = new R(this.database);
+  }
+  async open(e = !1) {
+    if (e) {
+      const t = await this.db.query(`
+                SELECT tablename FROM pg_tables 
+                WHERE schemaname = 'public' 
+                AND tablename NOT LIKE 'pg_%'
+                AND tablename NOT LIKE 'sql_%'
+            `);
+      for (const s of t.rows)
+        await this.db.query(`DROP TABLE IF EXISTS "${s.tablename}" CASCADE`);
+    }
+    await this.idSystem.setup();
+  }
+  async openForSchemaRead() {
+  }
+  async setupInternalComputationState() {
+    await this.scheme(`
+CREATE TABLE IF NOT EXISTS "_ComputationState_" (
+    "key" TEXT PRIMARY KEY,
+    "numberValue" NUMERIC NULL,
+    "booleanValue" BOOLEAN NULL,
+    "stringValue" TEXT NULL,
+    "jsonValue" JSON NULL
+)`, "setup computation state table");
+  }
+  async setupScopedSequenceState() {
+    await this.scheme(`
+CREATE TABLE IF NOT EXISTS "_ScopedSequence_" (
+    "sequenceName" TEXT NOT NULL,
+    "scopeKey" TEXT NOT NULL,
+    "scope" JSONB NOT NULL,
+    "lastValue" NUMERIC NOT NULL,
+    PRIMARY KEY ("sequenceName", "scopeKey")
+)`, "setup scoped sequence table");
+  }
+  async query(e, t = [], s = "") {
+    const r = l.getStore(), n = this.logger.child(r?.logContext || {});
+    n.info({
+      type: "query",
+      name: s,
+      sql: e,
+      params: t
+    });
+    try {
+      return (await this.db.query(e, t)).rows;
+    } catch (i) {
+      throw n.error({
+        type: "query",
+        name: s,
+        sql: e,
+        params: t,
+        error: i instanceof Error ? i.message : String(i)
+      }), i;
+    }
+  }
+  async update(e, t, s, r = "") {
+    const n = l.getStore(), i = this.logger.child(n?.logContext || {}), o = `${e} ${s ? `RETURNING "${s}" AS id` : ""}`, a = t.map((c) => typeof c == "object" && c !== null ? JSON.stringify(c) : c);
+    return i.info({
+      type: "update",
+      name: r,
+      sql: o,
+      params: a
+    }), (await this.db.query(o, a)).rows;
+  }
+  async insert(e, t, s = "") {
+    const r = l.getStore(), n = this.logger.child(r?.logContext || {}), i = t.map((a) => typeof a == "object" && a !== null ? JSON.stringify(a) : a);
+    n.info({
+      type: "insert",
+      name: s,
+      sql: e,
+      params: i
+    });
+    const o = `${e} RETURNING "${p}"`;
+    try {
+      return (await this.db.query(o, i)).rows[0];
+    } catch (a) {
+      throw n.error({
+        type: "insert",
+        name: s,
+        sql: o,
+        params: i,
+        error: a instanceof Error ? a.message : String(a)
+      }), a;
+    }
+  }
+  async delete(e, t, s = "") {
+    const r = l.getStore();
+    return this.logger.child(r?.logContext || {}).info({
+      type: "delete",
+      name: s,
+      sql: e,
+      params: t
+    }), (await this.db.query(e, t)).rows;
+  }
+  async scheme(e, t = "") {
+    const s = l.getStore(), r = this.logger.child(s?.logContext || {});
+    r.info({
+      type: "scheme",
+      name: t,
+      sql: e
+    });
+    try {
+      return await this.db.query(e);
+    } catch (n) {
+      throw r.error({
+        type: "scheme",
+        name: t,
+        sql: e,
+        error: n instanceof Error ? n.message : String(n)
+      }), n;
+    }
+  }
+  close() {
+    return this.db.close();
+  }
+  async getAutoId(e) {
+    return this.idSystem.getAutoId(e);
+  }
+  parseMatchExpression(e, t, s, r, n, i, o) {
+    if (r.toLowerCase() === "json") {
+      if (t[0].toLowerCase() === "contains") {
+        const a = s.split(".").map((c) => `"${c}"`).join(".");
+        return {
+          fieldValue: `IS NOT NULL AND ${o()} = ANY (SELECT json_array_elements_text(${a}))`,
+          fieldParams: [t[1]]
+        };
+      }
+      if (t[0] === "=" || t[0] === "!=")
+        return {
+          fieldValue: `IS NOT NULL AND ${s.split(".").map((c) => `"${c}"`).join(".")}::jsonb ${t[0]} ${o()}::jsonb`,
+          fieldParams: [JSON.stringify(t[1])]
+        };
+    }
+  }
+  getPlaceholder() {
+    let e = 0;
+    return () => (e++, `$${e}`);
+  }
+  mapToDBFieldType(e, t) {
+    return e === "pk" ? "SERIAL PRIMARY KEY" : e === "id" ? "UUID" : t || e === "object" ? "JSON" : e === "string" ? "TEXT" : e === "boolean" ? "BOOL" : e === "number" ? "DOUBLE PRECISION" : e === "timestamp" ? "TIMESTAMP" : e;
+  }
+}
+class M {
+  constructor(e) {
+    this.db = e, this.allocating = Promise.resolve();
+  }
+  async setup() {
+    await this.db.scheme('CREATE Table IF NOT EXISTS "_IDS_" (last INTEGER, name VARCHAR(191), PRIMARY KEY (name))'), (await this.db.query(
+      "SELECT COUNT(1) AS cnt FROM information_schema.statistics WHERE table_schema = DATABASE() AND table_name = '_IDS_' AND index_name = 'PRIMARY'",
+      [],
+      "check _IDS_ primary key"
+    ))[0]?.cnt || await this.db.scheme('ALTER TABLE "_IDS_" MODIFY name VARCHAR(191), ADD PRIMARY KEY (name)');
+  }
+  async getAutoId(e) {
+    const t = this.allocating.then(async () => (await this.db.update(
+      `INSERT INTO "_IDS_" (name, last) VALUES (?, LAST_INSERT_ID(1))
+ON DUPLICATE KEY UPDATE last = LAST_INSERT_ID(last + 1)`,
+      [e],
+      void 0,
+      `allocate next id for ${e}`
+    ), (await this.db.query("SELECT LAST_INSERT_ID() AS id", [], `read allocated id for ${e}`))[0].id));
+    return this.allocating = t.catch(() => {
+    }), t;
+  }
+}
+class k {
+  constructor(e, t = {}) {
+    this.database = e, this.options = t, this.supportsSelectForUpdate = !0, this.maxQueryParams = 65e3, this.transactionCapability = {
+      transactions: !1,
+      isolationLevels: [],
+      transactionBoundConnection: !1,
+      concurrentTransactions: "unsupported",
+      nestedStrategy: "unsupported",
+      notes: [
+        "The current MySQL driver has no transaction-bound connection implementation; strong dispatch transactions are unsupported."
+      ]
+    }, this.schemaDialect = {
+      name: "mysql",
+      maxIdentifierLength: 64,
+      supportsCreateIndexIfNotExists: !1,
+      encodeLiteral: S,
+      constraints: { unique: !1, filteredUnique: !1, nonNull: !1 }
+    }, this.idSystem = new M(this), this.logger = this.options?.logger || g;
+  }
+  async open(e = !1) {
+    const t = await E.createConnection({
+      ...this.options
+    });
+    await t.connect();
+    try {
+      const s = `\`${this.database.replace(/`/g, "``")}\``, [r] = await t.query("SHOW DATABASES LIKE ?", [this.database]);
+      r.length === 0 ? await t.query(`CREATE DATABASE ${s}`) : e && (await t.query(`DROP DATABASE ${s}`), await t.query(`CREATE DATABASE ${s}`));
+    } finally {
+      await t.end();
+    }
+    this.db = await E.createConnection({
+      ...this.options,
+      database: this.database
+    }), await this.db.connect(), await this.db.query("SET sql_mode='ANSI_QUOTES'"), await this.idSystem.setup();
+  }
+  async openForSchemaRead() {
+    this.db || (this.db = await E.createConnection({
+      ...this.options,
+      database: this.database
+    }), await this.db.connect(), await this.db.query("SET sql_mode='ANSI_QUOTES'"));
+  }
+  async query(e, t = [], s = "") {
+    const r = l.getStore(), n = this.logger.child(r?.logContext || {}), i = t.map((o) => o === !1 ? 0 : o === !0 ? 1 : o);
+    return n.info({
+      type: "query",
+      name: s,
+      sql: e,
+      params: i
+    }), (await this.db.query(e, i))[0];
+  }
+  async update(e, t, s, r = "") {
+    const n = l.getStore(), i = this.logger.child(n?.logContext || {}), o = t.map((a) => typeof a == "object" && a !== null ? JSON.stringify(a) : a === !1 ? 0 : a === !0 ? 1 : a);
+    return i.info({
+      type: "update",
+      name: r,
+      sql: e,
+      params: o
+    }), (await this.db.query(e, o))[0];
+  }
+  async insert(e, t, s = "") {
+    const r = l.getStore(), n = this.logger.child(r?.logContext || {}), i = t.map((c) => typeof c == "object" && c !== null ? JSON.stringify(c) : c === !1 ? 0 : c === !0 ? 1 : c);
+    n.info({
+      type: "insert",
+      name: s,
+      sql: e,
+      params: i
+    }), await this.db.query(e, i);
+    const [o] = await this.db.query("SELECT LAST_INSERT_ID();");
+    return { id: o[0]["LAST_INSERT_ID()"] };
+  }
+  async delete(e, t, s = "") {
+    const r = l.getStore(), n = this.logger.child(r?.logContext || {}), i = t.map((o) => o === !1 ? 0 : o === !0 ? 1 : o);
+    return n.info({
+      type: "delete",
+      name: s,
+      sql: e,
+      params: i
+    }), (await this.db.query(e, i))[0];
+  }
+  async scheme(e, t = "") {
+    const s = l.getStore();
+    return this.logger.child(s?.logContext || {}).info({
+      type: "scheme",
+      name: t,
+      sql: e
+    }), await this.db.query(e);
+  }
+  close() {
+    return this.db.end();
+  }
+  async getAutoId(e) {
+    return this.idSystem.getAutoId(e);
+  }
+  parseMatchExpression(e, t, s, r, n, i, o) {
+    if (r === "JSON") {
+      if (t[0].toLowerCase() === "contains")
+        return {
+          fieldValue: `IS NOT NULL AND JSON_CONTAINS(${s.split(".").map((c) => `"${c}"`).join(".")}, ${o()}, '$')`,
+          fieldParams: [JSON.stringify(t[1])]
+        };
+      if (t[0] === "=" || t[0] === "!=")
+        return {
+          fieldValue: `IS NOT NULL AND ${s.split(".").map((c) => `"${c}"`).join(".")} ${t[0]} CAST(${o()} AS JSON)`,
+          fieldParams: [JSON.stringify(t[1])]
+        };
+    }
+  }
+  getPlaceholder() {
+    return () => "?";
+  }
+  mapToDBFieldType(e, t) {
+    return e === "pk" ? "INT AUTO_INCREMENT PRIMARY KEY" : e === "id" ? "INT" : t || e === "object" ? "JSON" : e === "string" ? "TEXT" : e === "boolean" ? "INT(2)" : e === "number" ? "DOUBLE" : e === "timestamp" ? "TIMESTAMP" : e;
+  }
+}
+export {
+  k as MysqlDB,
+  v as PGLiteDB,
+  W as PostgreSQLDB,
+  K as SQLiteDB
+};
+//# sourceMappingURL=drivers.js.map