tempest-db-js 0.2.0 → 0.3.0

package/dist/index.cjs

@@ -288,7 +288,9 @@ var DIALECT_ALIASES = {
   sqlite3: "sqlite",
   postgresql: "postgresql",
   postgres: "postgresql",
-  pg: "postgresql"
+  pg: "postgresql",
+  mysql: "mysql",
+  mariadb: "mysql"
 };
 function splitScheme(scheme) {
   const plus = scheme.indexOf("+");
@@ -328,10 +330,10 @@ function parseSqlite(raw, driver, rest) {
     raw
   };
 }
-function parsePostgres(raw, driver, rest) {
+function parseNetworkUrl(raw, driver, rest, dialect) {
   let parsed;
   try {
-    parsed = new URL(`postgresql:${rest}`);
+    parsed = new URL(`${dialect}:${rest}`);
   } catch {
     throw new InvalidDatabaseUrl(raw, "could not parse host/credentials");
   }
@@ -339,7 +341,7 @@ function parsePostgres(raw, driver, rest) {
   const options = {};
   for (const [key, value] of parsed.searchParams) options[key] = value;
   return {
-    dialect: "postgresql",
+    dialect,
     driver,
     host: parsed.hostname || null,
     port: parsed.port ? Number(parsed.port) : null,
@@ -364,7 +366,8 @@ function parseDatabaseUrl(url) {
     throw new InvalidDatabaseUrl(url, `unknown dialect ${JSON.stringify(base)}`);
   }
   const rest = url.slice(schemeEnd + 1);
-  return dialect === "sqlite" ? parseSqlite(url, driver, rest) : parsePostgres(url, driver, rest);
+  if (dialect === "sqlite") return parseSqlite(url, driver, rest);
+  return parseNetworkUrl(url, driver, rest, dialect);
 }
 function detectDialect(url) {
   return parseDatabaseUrl(url).dialect;
@@ -663,18 +666,30 @@ var BaseDialect = class _BaseDialect {
     const rowsSql = node.values.map(() => `(${columns.map(() => this.placeholder(++position)).join(", ")})`).join(", ");
     let sql2 = `INSERT INTO ${this.quoteId(node.table)} (${colSql}) VALUES ${rowsSql}`;
     if (node.onConflict) {
-      const target = node.onConflict.target.map((c) => this.quoteId(c)).join(", ");
-      if (node.onConflict.update === "nothing") {
-        sql2 += ` ON CONFLICT (${target}) DO NOTHING`;
-      } else {
-        const assignments = conflictCols.map((c) => `${this.quoteId(c)} = ${this.placeholder(++position)}`).join(", ");
-        sql2 += ` ON CONFLICT (${target}) DO UPDATE SET ${assignments}`;
-      }
+      sql2 += this.renderConflict(
+        node.onConflict,
+        conflictCols,
+        () => this.placeholder(++position)
+      );
     }
     sql2 += this.compileReturning(node.returning);
     _BaseDialect.insertTemplates.set(key, sql2);
     return sql2;
   }
+  /**
+   * Render the conflict-handling clause. Standard SQL (SQLite/PostgreSQL) uses
+   * `ON CONFLICT (...) DO NOTHING | DO UPDATE SET ...`; MySQL overrides this.
+   *
+   * @param onConflict The conflict clause from the node.
+   * @param conflictCols The columns to overwrite on `DO UPDATE` (empty for nothing).
+   * @param nextPlaceholder Yields the next positional placeholder (advances the count).
+   */
+  renderConflict(onConflict, conflictCols, nextPlaceholder) {
+    const target = onConflict.target.map((c) => this.quoteId(c)).join(", ");
+    if (onConflict.update === "nothing") return ` ON CONFLICT (${target}) DO NOTHING`;
+    const assignments = conflictCols.map((c) => `${this.quoteId(c)} = ${nextPlaceholder()}`).join(", ");
+    return ` ON CONFLICT (${target}) DO UPDATE SET ${assignments}`;
+  }
   compileUpdate(node, params) {
     const sets = Object.entries(node.set).map(([col, value]) => `${this.quoteId(col)} = ${params.bind(value)}`).join(", ");
     let sql2 = `UPDATE ${this.quoteId(node.table)} SET ${sets}`;
@@ -812,8 +827,46 @@ var PostgresDialect = class extends BaseDialect {
     return `${column2} ILIKE ${param}`;
   }
 };
+var mysqlQuotedIds = /* @__PURE__ */ new Map();
+var MysqlDialect = class extends BaseDialect {
+  name = "mysql";
+  placeholder() {
+    return "?";
+  }
+  ilike(column2, param) {
+    return `${column2} LIKE ${param}`;
+  }
+  quoteId(name) {
+    const cached = mysqlQuotedIds.get(name);
+    if (cached !== void 0) return cached;
+    const quoted = `\`${name.replace(/`/g, "``")}\``;
+    mysqlQuotedIds.set(name, quoted);
+    return quoted;
+  }
+  renderConflict(onConflict, conflictCols, nextPlaceholder) {
+    if (onConflict.update === "nothing") {
+      const col = this.quoteId(onConflict.target[0] ?? "id");
+      return ` ON DUPLICATE KEY UPDATE ${col} = ${col}`;
+    }
+    const assignments = conflictCols.map((c) => `${this.quoteId(c)} = ${nextPlaceholder()}`).join(", ");
+    return ` ON DUPLICATE KEY UPDATE ${assignments}`;
+  }
+  compileReturning(returning) {
+    if (returning === null) return "";
+    throw new Error(
+      "RETURNING is not supported on MySQL \u2014 insert, then SELECT by key (e.g. LAST_INSERT_ID())."
+    );
+  }
+};
 function getDialect(name) {
-  return name === "sqlite" ? new SqliteDialect() : new PostgresDialect();
+  switch (name) {
+    case "sqlite":
+      return new SqliteDialect();
+    case "postgresql":
+      return new PostgresDialect();
+    case "mysql":
+      return new MysqlDialect();
+  }
 }
 
 // src/join.ts
@@ -1576,12 +1629,76 @@ function createEngine(url, options) {
       options?.onQuery
     );
   }
+  if (parsed.dialect === "mysql") {
+    return new AsyncEngine(
+      createMysqlDriver(parsed.raw, options?.pool),
+      "mysql",
+      options?.onQuery
+    );
+  }
   return new AsyncEngine(
     createPostgresDriver(parsed.raw, options?.pool),
     "postgresql",
     options?.onQuery
   );
 }
+function encodeMysqlParam(value) {
+  if (value === void 0 || value === null) return null;
+  if (typeof value === "boolean") return value ? 1 : 0;
+  if (value instanceof Uint8Array) return value;
+  if (value instanceof Date) return value;
+  if (typeof value === "object") return JSON.stringify(value);
+  return value;
+}
+function toMysqlResult(rows) {
+  if (Array.isArray(rows)) {
+    return { rows, changes: 0 };
+  }
+  const header = rows;
+  return { rows: [], changes: header.affectedRows ?? 0 };
+}
+function createMysqlDriver(url, pool) {
+  let poolHandle;
+  const ensure = async () => {
+    if (poolHandle) return;
+    const moduleName = "mysql2/promise";
+    const mod = await import(
+      /* @vite-ignore */
+      moduleName
+    );
+    const opts = { uri: url };
+    if (pool?.size !== void 0) opts.connectionLimit = pool.size;
+    if (pool?.idleTimeoutMs !== void 0) opts.idleTimeout = pool.idleTimeoutMs;
+    if (pool?.connectTimeoutMs !== void 0) opts.connectTimeout = pool.connectTimeoutMs;
+    poolHandle = mod.createPool(opts);
+  };
+  const runOn = async (queryable, sql2, params) => {
+    const [rows] = await queryable.query(sql2, params.map(encodeMysqlParam));
+    return toMysqlResult(rows);
+  };
+  return {
+    async execute(sql2, params) {
+      await ensure();
+      return runOn(poolHandle, sql2, params);
+    },
+    async reserve() {
+      await ensure();
+      const conn = await poolHandle.getConnection();
+      return {
+        execute: (sql2, params) => runOn(conn, sql2, params),
+        async release() {
+          conn.release();
+        },
+        async close() {
+          conn.release();
+        }
+      };
+    },
+    async close() {
+      if (poolHandle) await poolHandle.end();
+    }
+  };
+}
 function toPostgresResult(rows) {
   const arr = rows;
   return { rows: Array.from(arr), changes: arr.count ?? arr.length };
@@ -1785,6 +1902,7 @@ exports.InsertBuilder = InsertBuilder;
 exports.InvalidDatabaseUrl = InvalidDatabaseUrl;
 exports.JoinBuilder = JoinBuilder;
 exports.Model = Model;
+exports.MysqlDialect = MysqlDialect;
 exports.NoResultError = NoResultError;
 exports.NodeSqliteDriver = NodeSqliteDriver;
 exports.OPERATORS = OPERATORS;