@antfly/embedded 0.0.0-stage → 0.3.0-rc.1

package/dist/chunk-ELM44XQ4.js

@@ -0,0 +1,168 @@
+// ../../node_modules/.pnpm/tsup@8.5.1_jiti@2.7.0_postcss@8.5.15_supports-color@10.2.2_tsx@4.22.4_typescript@5.9.3_yaml@2.9.0/node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var getFilename = () => fileURLToPath(import.meta.url);
+var __filename = /* @__PURE__ */ getFilename();
+
+// src/sql-types.ts
+var SqlError = class extends Error {
+  constructor(diagnostic, transactionId) {
+    super(`${diagnostic.code}: ${diagnostic.message}`);
+    this.diagnostic = diagnostic;
+    this.transactionId = transactionId;
+    this.name = "SqlError";
+    this.sqlstate = diagnostic.code;
+  }
+  diagnostic;
+  transactionId;
+  sqlstate;
+};
+
+// src/sql.ts
+function request(statement, parameters, session, streaming = false) {
+  return JSON.stringify(
+    { statement, parameters, session_id: session, limit: streaming ? void 0 : 4096 },
+    (_key, value) => {
+      if (typeof value === "bigint") {
+        if (value < -(1n << 63n) || value >= 1n << 63n)
+          throw new RangeError("integer parameter is outside the signed 64-bit range");
+        return value.toString();
+      }
+      if (typeof value === "number" && (!Number.isFinite(value) || Number.isInteger(value) && !Number.isSafeInteger(value)))
+        throw new RangeError("use bigint for integer parameters outside JavaScript's safe range");
+      return value;
+    }
+  );
+}
+function result(wire) {
+  return {
+    columns: wire.columns,
+    commandTag: wire.command_tag,
+    rowsAffected: BigInt(wire.rows_affected),
+    rows: wire.rows.map(
+      (row, rowIndex) => Object.fromEntries(
+        wire.columns.map((column, index) => [
+          column.name,
+          wire.sql_nulls?.[rowIndex]?.[index] ? null : column.type === "integer" && row[index] !== null ? BigInt(row[index]) : row[index]
+        ])
+      )
+    )
+  };
+}
+var Connection = class _Connection {
+  constructor(database, session, direct = false) {
+    this.database = database;
+    this.session = session;
+    this.direct = direct;
+  }
+  database;
+  session;
+  direct;
+  #pending = Promise.resolve();
+  #closed = false;
+  static async open(database) {
+    return new _Connection(database, await database.openSqlSession());
+  }
+  #run(operation) {
+    if (this.#closed) return Promise.reject(new Error("SQL connection is closed"));
+    if (this.direct) return operation();
+    const work = this.#pending.then(operation);
+    this.#pending = work.catch(() => void 0);
+    return work;
+  }
+  execute(statement, parameters = []) {
+    return this.#run(
+      async () => result(
+        await this.database.sqlJson(request(statement, parameters, this.session))
+      )
+    );
+  }
+  query(statement, parameters = []) {
+    return this.#run(async () => {
+      let cursor;
+      try {
+        cursor = await this.database.openSqlCursor(
+          request(statement, parameters, this.session, true)
+        );
+      } catch (error) {
+        if (!(error instanceof SqlError) || error.sqlstate !== "0A000") throw error;
+        return result(
+          await this.database.sqlJson(request(statement, parameters, this.session))
+        );
+      }
+      let output;
+      try {
+        while (true) {
+          const page = await this.database.fetchSqlCursor(cursor);
+          const decoded = result(page.result);
+          if (output) output.rows.push(...decoded.rows);
+          else output = decoded;
+          if (page.exhausted) return output;
+        }
+      } finally {
+        await this.database.closeSqlCursor(cursor);
+      }
+    });
+  }
+  async *stream(statement, parameters = [], chunkSize = 128) {
+    if (!Number.isInteger(chunkSize) || chunkSize < 1 || chunkSize > 4096)
+      throw new RangeError("chunkSize must be 1..4096");
+    if (this.#closed) throw new Error("SQL connection is closed");
+    const previous = this.#pending;
+    let release = () => {
+    };
+    if (!this.direct)
+      this.#pending = new Promise((resolve) => {
+        release = resolve;
+      });
+    await previous;
+    let cursor;
+    try {
+      cursor = await this.database.openSqlCursor(
+        request(statement, parameters, this.session, true)
+      );
+      while (true) {
+        const page = await this.database.fetchSqlCursor(cursor, chunkSize);
+        yield result(page.result);
+        if (page.exhausted) break;
+      }
+    } finally {
+      try {
+        if (cursor !== void 0) await this.database.closeSqlCursor(cursor);
+      } finally {
+        release();
+      }
+    }
+  }
+  transaction(operation) {
+    return this.#run(async () => {
+      const transaction = new _Connection(this.database, this.session, true);
+      await transaction.execute("BEGIN ISOLATION LEVEL READ COMMITTED");
+      try {
+        const value = await operation(transaction);
+        await transaction.execute("COMMIT");
+        return value;
+      } catch (error) {
+        try {
+          await transaction.execute("ROLLBACK");
+        } catch {
+        }
+        throw error;
+      } finally {
+        transaction.#closed = true;
+      }
+    });
+  }
+  async close() {
+    if (this.#closed) return;
+    this.#closed = true;
+    await this.#pending;
+    await this.database.closeSqlSession(this.session);
+  }
+};
+
+export {
+  __filename,
+  SqlError,
+  Connection
+};