tempest-db-js 0.2.0 → 0.4.0

package/dist/{chunk-AGDD7K3F.js → chunk-JR4MLFQN.js}

@@ -285,7 +285,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("+");
@@ -325,10 +327,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");
   }
@@ -336,7 +338,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,
@@ -361,7 +363,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;
@@ -660,18 +663,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}`;
@@ -809,8 +824,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
@@ -1573,12 +1626,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 };
@@ -1631,7 +1748,8 @@ function createPostgresDriver(url, pool) {
 var DEFAULT_FLAGS = {
   primaryKey: false,
   notNull: false,
-  hasDefault: false
+  hasDefault: false,
+  unique: false
 };
 var sql = {
   /** Current timestamp at insert (`CURRENT_TIMESTAMP` / `now()`). */
@@ -1651,23 +1769,38 @@ var sql = {
 function isDefaultValue(value) {
   return typeof value === "object" && value !== null && "kind" in value && (value.kind === "literal" || value.kind === "expression");
 }
+function parseReference(ref, options) {
+  const dot = ref.lastIndexOf(".");
+  if (dot <= 0 || dot === ref.length - 1) {
+    throw new Error(`Invalid foreign key reference "${ref}"; expected "table.column".`);
+  }
+  return {
+    table: ref.slice(0, dot),
+    column: ref.slice(dot + 1),
+    onDelete: options?.onDelete,
+    onUpdate: options?.onUpdate
+  };
+}
 var Column = class _Column {
-  constructor(type, flags, defaultValue = null, onUpdateValue = null) {
+  constructor(type, flags, defaultValue = null, onUpdateValue = null, reference = null) {
     this.type = type;
     this.flags = flags;
     this.defaultValue = defaultValue;
     this.onUpdateValue = onUpdateValue;
+    this.reference = reference;
   }
   type;
   flags;
   defaultValue;
   onUpdateValue;
+  reference;
   primaryKey() {
     return new _Column(
       this.type,
       { ...this.flags, primaryKey: true, hasDefault: true },
       this.defaultValue,
-      this.onUpdateValue
+      this.onUpdateValue,
+      this.reference
     );
   }
   notNull() {
@@ -1675,7 +1808,40 @@ var Column = class _Column {
       this.type,
       { ...this.flags, notNull: true },
       this.defaultValue,
-      this.onUpdateValue
+      this.onUpdateValue,
+      this.reference
+    );
+  }
+  /**
+   * Add a `UNIQUE` constraint to the column (mirrors SQLAlchemy's
+   * `mapped_column(unique=True)`). DDL-only — does not change the inferred type.
+   */
+  unique() {
+    return new _Column(
+      this.type,
+      { ...this.flags, unique: true },
+      this.defaultValue,
+      this.onUpdateValue,
+      this.reference
+    );
+  }
+  /**
+   * Declare a foreign-key reference to another table's column, à la SQLAlchemy's
+   * `mapped_column(ForeignKey("table.column", ondelete=...))`. DDL-only — does
+   * not change the inferred type.
+   *
+   * @param ref The target as `"table.column"` (e.g. `"users.id"`).
+   * @param options Optional `onDelete` / `onUpdate` referential actions.
+   * @returns A new column carrying the reference.
+   * @throws Error When `ref` is not a valid `"table.column"` string.
+   */
+  references(ref, options) {
+    return new _Column(
+      this.type,
+      this.flags,
+      this.defaultValue,
+      this.onUpdateValue,
+      parseReference(ref, options)
     );
   }
   /**
@@ -1688,7 +1854,8 @@ var Column = class _Column {
       this.type,
       { ...this.flags, hasDefault: true },
       resolved,
-      this.onUpdateValue
+      this.onUpdateValue,
+      this.reference
     );
   }
   /**
@@ -1697,7 +1864,7 @@ var Column = class _Column {
    */
   onUpdate(value) {
     const resolved = isDefaultValue(value) ? value : { kind: "literal", value };
-    return new _Column(this.type, this.flags, this.defaultValue, resolved);
+    return new _Column(this.type, this.flags, this.defaultValue, resolved, this.reference);
   }
 };
 function makeColumn(kind, meta = {}) {
@@ -1751,8 +1918,36 @@ var column = {
   /** `ENUM(...values)` → a string-literal union of the given values. */
   enum: (...values) => makeColumn("enum", { values })
 };
+function unique(...columns) {
+  if (columns.length === 0) {
+    throw new Error("unique() requires at least one column.");
+  }
+  return { kind: "unique", columns };
+}
+function foreignKey(columns, refTable, refColumns, options) {
+  if (columns.length === 0 || columns.length !== refColumns.length) {
+    throw new Error(
+      "foreignKey() requires matching, non-empty local and referenced column lists."
+    );
+  }
+  return {
+    kind: "foreignKey",
+    name: options?.name,
+    columns,
+    refTable,
+    refColumns,
+    onDelete: options?.onDelete,
+    onUpdate: options?.onUpdate
+  };
+}
 var Model = class {
   static tablename;
+  /**
+   * Optional table-level constraints (composite unique / foreign keys), returned
+   * by a thunk so forward references resolve lazily. Mirrors SQLAlchemy's
+   * `__table_args__`.
+   */
+  static tableArgs;
 };
 var columnsCache = /* @__PURE__ */ new WeakMap();
 function columnsOf(model) {
@@ -1769,6 +1964,6 @@ function columnsOf(model) {
   return out;
 }
 
-export { ActiveRecord, Agg, AsyncEngine, AsyncResult, AsyncSession, BaseDialect, BaseRepository, Column, DeleteBuilder, InsertBuilder, InvalidDatabaseUrl, JoinBuilder, Model, NoResultError, NodeSqliteDriver, OPERATORS, PostgresDialect, QueryExecutionError, RecordNotFound, SelectBuilder, SqliteDialect, SyncEngine, SyncResult, SyncSession, UpdateBuilder, ValidationError, activeRecord, and, avg, belongsTo, column, columnsOf, count, createEngine, createSyncEngine, del, detectDialect, fromDict, getDialect, hasMany, insert, isCondition, join, loadRelations, max, min, not, or, parse, parseDatabaseUrl, select, sql, stringify, sum, toCondNode, toDict, toJSON, update };
-//# sourceMappingURL=chunk-AGDD7K3F.js.map
-//# sourceMappingURL=chunk-AGDD7K3F.js.map
+export { ActiveRecord, Agg, AsyncEngine, AsyncResult, AsyncSession, BaseDialect, BaseRepository, Column, DeleteBuilder, InsertBuilder, InvalidDatabaseUrl, JoinBuilder, Model, MysqlDialect, NoResultError, NodeSqliteDriver, OPERATORS, PostgresDialect, QueryExecutionError, RecordNotFound, SelectBuilder, SqliteDialect, SyncEngine, SyncResult, SyncSession, UpdateBuilder, ValidationError, activeRecord, and, avg, belongsTo, column, columnsOf, count, createEngine, createSyncEngine, del, detectDialect, foreignKey, fromDict, getDialect, hasMany, insert, isCondition, join, loadRelations, max, min, not, or, parse, parseDatabaseUrl, select, sql, stringify, sum, toCondNode, toDict, toJSON, unique, update };
+//# sourceMappingURL=chunk-JR4MLFQN.js.map
+//# sourceMappingURL=chunk-JR4MLFQN.js.map