@nextlyhq/adapter-drizzle 0.0.2-alpha.6 → 0.0.2-alpha.60

package/dist/index.mjs

@@ -1,8 +1,8 @@
-import { getTableColumns, desc, asc, and, or, not, like, notBetween, between, isNotNull, isNull, notInArray, inArray, ilike, lte, gte, lt, gt, ne, eq } from 'drizzle-orm';
+import { getColumns, desc, asc, and, or, not, like, notBetween, between, isNotNull, isNull, notInArray, inArray, ilike, lte, gte, lt, gt, ne, eq } from 'drizzle-orm';
 
 // src/adapter.ts
 function buildDrizzleWhere(table, where) {
-  const columns = getTableColumns(table);
+  const columns = getColumns(table);
   return processWhereClause(columns, where);
 }
 function processWhereClause(columns, where) {
@@ -106,6 +106,51 @@ function createDatabaseError(options) {
 }
 
 // src/adapter.ts
+var DATE_DATA_TYPE = /(?:^|\s)date$/;
+var WALL_CLOCK_ALIAS_STEM = "__nx_wc";
+var WALL_CLOCK_PATTERN = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?$/;
+function parseWallClockAsUtc(text) {
+  const match = WALL_CLOCK_PATTERN.exec(text.trim());
+  if (!match) return void 0;
+  const [, year, month, day, hour, minute, second, fraction = ""] = match;
+  const millis = Number(`${fraction}000`.slice(0, 3));
+  const parsed = new Date(
+    Date.UTC(
+      Number(year),
+      Number(month) - 1,
+      Number(day),
+      Number(hour),
+      Number(minute),
+      Number(second),
+      millis
+    )
+  );
+  if (Number(year) < 100) parsed.setUTCFullYear(Number(year));
+  return parsed;
+}
+function isDateColumn(colDef) {
+  if (!colDef || typeof colDef !== "object") return false;
+  const candidate = colDef;
+  return typeof candidate.mapFromDriverValue === "function" && typeof candidate.mapToDriverValue === "function" && DATE_DATA_TYPE.test(String(candidate.dataType));
+}
+function carriesTimeZone(colDef) {
+  return colDef.withTimezone === true;
+}
+function affectedRowCount(result) {
+  if (Array.isArray(result)) {
+    const header = result[0];
+    if (header && typeof header.affectedRows === "number") {
+      return header.affectedRows;
+    }
+    return result.length;
+  }
+  const record = result;
+  const rowCount = record?.rowCount;
+  if (typeof rowCount === "number") return rowCount;
+  const changes = record?.changes;
+  if (typeof changes === "number") return changes;
+  return 0;
+}
 var DrizzleAdapter = class {
   // ============================================================
   // Drizzle Query API Support
@@ -134,6 +179,45 @@ var DrizzleAdapter = class {
   getTableObject(tableName) {
     return this.tableResolver?.getTable(tableName) ?? null;
   }
+  /**
+   * Run a Drizzle-built statement and return its rows.
+   *
+   * @remarks
+   * The CRUD methods resolve their table through the schema registry and reject
+   * any name it does not declare, which leaves no way to read from a table the
+   * ORM does not know — one mid-rename, above all — except by assembling SQL and
+   * quoting identifiers by hand. This takes Drizzle's `sql` template instead, so
+   * the dialect in use decides the quoting and the parameter binding.
+   *
+   * Concrete rather than abstract so existing adapters keep working unchanged.
+   * The three drivers disagree about both the call and the result: node-postgres
+   * returns `{ rows }`, mysql2 a `[rows, fields]` tuple, and better-sqlite3 has
+   * no `execute` at all and answers `all`. Keeping that here rather than at each
+   * call site is the point — a caller reasoning about it would be reasoning
+   * about a driver it cannot see.
+   *
+   * @param statement - Drizzle `sql` template to run
+   * @returns Rows the statement produced
+   */
+  async queryStatement(statement) {
+    if (this.getCapabilities().dialect === "sqlite") {
+      const db2 = this.getDrizzle();
+      return await db2.all(statement);
+    }
+    const db = this.getDrizzle();
+    const result = await db.execute(statement);
+    if (Array.isArray(result)) {
+      return Array.isArray(result[0]) ? result[0] : result;
+    }
+    if (typeof result === "object" && result !== null && Array.isArray(result.rows)) {
+      return result.rows;
+    }
+    throw this.createDatabaseError(
+      "query",
+      "Drizzle statement returned a result shape this adapter does not recognise; refusing to report it as an empty result.",
+      void 0
+    );
+  }
   /**
    * Map data keys from SQL column names (snake_case) to Drizzle JS property names (camelCase).
    * Drizzle schemas define columns as e.g. `createdAt: timestamp("created_at")` — the JS
@@ -173,6 +257,281 @@ var DrizzleAdapter = class {
     }
     return mapped;
   }
+  /**
+   * Map data keys from Drizzle JS property names to SQL column names for the
+   * raw-SQL transaction insert path. The transaction context builds INSERT
+   * statements from Object.keys(data) used directly as column identifiers, so a
+   * table whose Drizzle property names differ from its SQL column names
+   * (camelCase core tables like nextly_versions) needs its keys translated
+   * first. For tables whose property names already equal their column names
+   * (the dynamic dc_/single_/comp_ tables) every lookup is identity, so
+   * existing callers are unaffected.
+   */
+  mapKeysToSqlColumns(tableObj, data) {
+    if (!tableObj || typeof tableObj !== "object") return data;
+    const jsToSql = /* @__PURE__ */ new Map();
+    for (const [jsName, colDef] of Object.entries(
+      tableObj
+    )) {
+      if (colDef && typeof colDef === "object" && "name" in colDef && typeof colDef.name === "string") {
+        jsToSql.set(jsName, colDef.name);
+      }
+    }
+    if (jsToSql.size === 0) return data;
+    const out = {};
+    for (const [key, value] of Object.entries(data)) {
+      out[jsToSql.get(key) ?? key] = value;
+    }
+    return out;
+  }
+  /**
+   * Map a list of column identifiers (Drizzle property names) to their SQL
+   * column names, for the raw-SQL transaction insert paths that build a
+   * RETURNING clause from `options.returning`. Same identity behavior as
+   * `mapKeysToSqlColumns`: names that are already SQL columns (the dynamic
+   * dc_/single_/comp_ tables) pass through unchanged.
+   */
+  mapColumnNamesToSql(tableObj, names) {
+    if (!tableObj || typeof tableObj !== "object") return names;
+    const jsToSql = /* @__PURE__ */ new Map();
+    for (const [jsName, colDef] of Object.entries(
+      tableObj
+    )) {
+      if (colDef && typeof colDef === "object" && "name" in colDef && typeof colDef.name === "string") {
+        jsToSql.set(jsName, colDef.name);
+      }
+    }
+    if (jsToSql.size === 0) return names;
+    return names.map((n) => jsToSql.get(n) ?? n);
+  }
+  /**
+   * Remap a raw-SQL result row's KEYS from SQL column names to Drizzle property
+   * names, so the raw-SQL transaction insert paths return the same key casing
+   * as the non-transactional (Drizzle) insert. Keys only - values are left
+   * untouched, so this does not change how JSON/date columns are decoded. For
+   * tables whose property names already equal their SQL columns (the dynamic
+   * dc_/single_/comp_ tables) every lookup is identity, so existing callers see
+   * no change.
+   */
+  mapRowKeysToJs(tableObj, row) {
+    if (!tableObj || typeof tableObj !== "object" || !row || typeof row !== "object") {
+      return row;
+    }
+    const sqlToJs = /* @__PURE__ */ new Map();
+    for (const [jsName, colDef] of Object.entries(
+      tableObj
+    )) {
+      if (colDef && typeof colDef === "object" && "name" in colDef && typeof colDef.name === "string") {
+        sqlToJs.set(colDef.name, jsName);
+      }
+    }
+    if (sqlToJs.size === 0) return row;
+    const out = {};
+    for (const [key, value] of Object.entries(row)) {
+      out[sqlToJs.get(key) ?? key] = value;
+    }
+    return out;
+  }
+  /**
+   * Decode a raw-SQL result row's DATE column values the way a Drizzle query
+   * would, so a write answers with the same representation a read of the same
+   * column gives.
+   *
+   * A Drizzle query path runs every value through its column definition; a
+   * raw-SQL path does not, so a dialect that stores a timestamp as a number
+   * answers a write with that number while every read answers a `Date`. Only
+   * date columns are touched, and a value that is already a `Date` is left
+   * alone, so a driver that decodes on its own is unaffected.
+   *
+   * Runs after {@link mapRowKeysToJs}: keys are Drizzle property names by then,
+   * which is what the table definition is keyed by.
+   */
+  mapDateValuesFromDriver(tableObj, row) {
+    if (!tableObj || typeof tableObj !== "object" || !row || typeof row !== "object") {
+      return row;
+    }
+    let decoded;
+    for (const [jsName, colDef] of Object.entries(
+      tableObj
+    )) {
+      if (!isDateColumn(colDef)) continue;
+      const value = row[jsName];
+      if (value == null || value instanceof Date) continue;
+      decoded ??= { ...row };
+      decoded[jsName] = colDef.mapFromDriverValue(value);
+    }
+    return decoded ?? row;
+  }
+  /**
+   * Encode a row's DATE values the way a Drizzle query would before binding
+   * them, so what lands in the column does not depend on the server's timezone.
+   *
+   * A column declared without a time zone stores a wall clock and records
+   * nothing about which zone it belongs to, so both ends have to agree. Drizzle
+   * writes UTC and reads UTC. A driver handed a `Date` writes the LOCAL wall
+   * clock instead, and the same row then reads back shifted by the offset --
+   * on a UTC server the two agree and nothing is visibly wrong, which is why
+   * this survives CI.
+   *
+   * Only date columns are touched. A value that is not a `Date` is left as it
+   * is, so a caller that already encoded one is not encoded twice.
+   *
+   * Keys may be spelled either way at this point, so both the Drizzle property
+   * name and the SQL column name resolve.
+   */
+  mapDateValuesToDriver(tableObj, data) {
+    if (!tableObj || typeof tableObj !== "object" || !data) return data;
+    const dateColumns = /* @__PURE__ */ new Map();
+    for (const [jsName, colDef] of Object.entries(
+      tableObj
+    )) {
+      if (!isDateColumn(colDef)) continue;
+      dateColumns.set(jsName, colDef);
+      const sqlName = colDef.name;
+      if (typeof sqlName === "string") dateColumns.set(sqlName, colDef);
+    }
+    if (dateColumns.size === 0) return data;
+    let encoded;
+    for (const [key, value] of Object.entries(data)) {
+      if (!(value instanceof Date)) continue;
+      const column = dateColumns.get(key);
+      if (!column) continue;
+      encoded ??= { ...data };
+      encoded[key] = column.mapToDriverValue(value);
+    }
+    return encoded ?? data;
+  }
+  /**
+   * Bring a row about to be written through a raw-SQL statement into the shape
+   * a Drizzle query would have bound: SQL column names for keys, encoded values
+   * for date columns.
+   *
+   * The mirror of {@link mapRowFromRawSql}. The raw-SQL write paths exist
+   * because a dialect needs SQL a Drizzle query cannot express, not because
+   * their callers want different values in the table.
+   */
+  mapRowToRawSql(tableObj, data) {
+    return this.mapDateValuesToDriver(
+      tableObj,
+      this.mapKeysToSqlColumns(tableObj, data)
+    );
+  }
+  /**
+   * Bring a raw-SQL result row into the shape a Drizzle query would have
+   * produced: Drizzle property names for keys, decoded values for date columns.
+   *
+   * The raw-SQL write paths exist because a dialect needs SQL a Drizzle query
+   * cannot express, not because their callers want a different row shape, so
+   * every one of them ends here.
+   */
+  mapRowFromRawSql(tableObj, row, aliases = []) {
+    const mapped = this.mapDateValuesFromDriver(
+      tableObj,
+      this.mapRowKeysToJs(tableObj, row)
+    );
+    return this.applyWallClockAliases(mapped, aliases);
+  }
+  /**
+   * The date columns a statement is about to return, and the alias each one's
+   * wall clock is spelled out under.
+   *
+   * A driver turns a timestamp into a `Date` using ITS zone before any of this
+   * code runs, and that conversion is lossy: a wall clock inside a
+   * daylight-saving gap is a local time that does not exist, so the driver
+   * normalizes it and the original is gone. Asking the database for the wall
+   * clock as text alongside the row is the only way to read it exactly.
+   *
+   * `"*"` covers every date column; a projection covers only the ones it asked
+   * for, so a caller still gets back what it requested and nothing more.
+   */
+  dateWallClockAliases(tableObj, returning) {
+    if (!tableObj || typeof tableObj !== "object" || returning === void 0) {
+      return [];
+    }
+    const requested = returning === "*" ? void 0 : new Set(returning.map(String));
+    const taken = /* @__PURE__ */ new Set();
+    for (const [jsName, colDef] of Object.entries(
+      tableObj
+    )) {
+      taken.add(jsName);
+      const columnName = colDef.name;
+      if (typeof columnName === "string") taken.add(columnName);
+    }
+    let next = 0;
+    const freeAlias = () => {
+      let candidate = `${WALL_CLOCK_ALIAS_STEM}${next++}`;
+      while (taken.has(candidate)) {
+        candidate = `${WALL_CLOCK_ALIAS_STEM}${next++}`;
+      }
+      taken.add(candidate);
+      return candidate;
+    };
+    const aliases = [];
+    for (const [jsName, colDef] of Object.entries(
+      tableObj
+    )) {
+      if (!isDateColumn(colDef)) continue;
+      if (carriesTimeZone(colDef)) continue;
+      const sqlName = colDef.name;
+      if (typeof sqlName !== "string") continue;
+      if (requested && !requested.has(sqlName) && !requested.has(jsName)) {
+        continue;
+      }
+      aliases.push({ sqlName, alias: freeAlias(), jsName });
+    }
+    return aliases;
+  }
+  /**
+   * Replace each date in a row with the wall clock the database spelled out,
+   * read as UTC, and drop the aliases that carried it.
+   *
+   * The statement writes a UTC wall clock, so reading one back as UTC is what
+   * makes a write and a later read agree. Whatever the column actually stored
+   * is what arrives -- a column keeping only whole seconds reports whole
+   * seconds -- because this is the database's own text, not a value
+   * reconstructed from the one that was bound.
+   */
+  applyWallClockAliases(row, aliases) {
+    if (!row || typeof row !== "object" || aliases.length === 0) return row;
+    const record = row;
+    let resolved;
+    for (const { alias, jsName } of aliases) {
+      if (!(alias in record)) continue;
+      resolved ??= { ...record };
+      const text = resolved[alias];
+      delete resolved[alias];
+      if (typeof text !== "string") continue;
+      const parsed = parseWallClockAsUtc(text);
+      if (parsed !== void 0) resolved[jsName] = parsed;
+    }
+    return resolved ?? row;
+  }
+  /**
+   * Build a Drizzle column projection object (`{ propertyName: column }`) from a
+   * requested column list, used by `select` (columns) and `insert` (returning).
+   * A requested name resolves against either the Drizzle property name
+   * (camelCase) or the SQL column name (snake_case); the projection is keyed by
+   * the property name so the row shape matches a full select. Returns undefined
+   * for `"*"` or when nothing resolves, so callers fall back to all columns.
+   */
+  buildColumnProjection(tableObj, names) {
+    if (names == null || names === "*" || !tableObj || typeof tableObj !== "object") {
+      return void 0;
+    }
+    const cols = getColumns(tableObj);
+    const byAnyName = {};
+    for (const [jsName, col] of Object.entries(cols)) {
+      byAnyName[jsName] = { jsName, col };
+      const sqlName = col?.name;
+      if (typeof sqlName === "string") byAnyName[sqlName] = { jsName, col };
+    }
+    const projection = {};
+    for (const name of names) {
+      const hit = byAnyName[name];
+      if (hit) projection[hit.jsName] = hit.col;
+    }
+    return Object.keys(projection).length ? projection : void 0;
+  }
   // ============================================================
   // Connection Status (Default implementations, can override)
   // ============================================================
@@ -326,12 +685,13 @@ var DrizzleAdapter = class {
    * });
    * ```
    */
-  async select(table, options) {
+  async select(table, options, executor) {
     const tableObj = this.getTableObject(table);
     if (tableObj) {
       try {
-        const db = this.getDrizzle();
-        let query = db.select().from(tableObj);
+        const db = executor ?? this.getDrizzle();
+        const projection = options?.columns?.length ? this.buildColumnProjection(tableObj, options.columns) : void 0;
+        let query = projection ? db.select(projection).from(tableObj) : db.select().from(tableObj);
         if (options?.where) {
           const whereCondition = buildDrizzleWhere(
             tableObj,
@@ -342,7 +702,7 @@ var DrizzleAdapter = class {
           }
         }
         if (options?.orderBy?.length) {
-          const columns = getTableColumns(tableObj);
+          const columns = getColumns(tableObj);
           const orderClauses = options.orderBy.map((o) => {
             const col = columns[o.column];
             if (!col) return void 0;
@@ -358,6 +718,16 @@ var DrizzleAdapter = class {
         if (options?.offset !== void 0) {
           query = query.offset(options.offset);
         }
+        if (options?.forUpdate && !executor) {
+          throw this.createDatabaseError(
+            "query",
+            "forUpdate requires a transaction executor: a lock request on the pooled connection takes no durable lock and cannot prevent a concurrent write.",
+            void 0
+          );
+        }
+        if (options?.forUpdate && this.dialect !== "sqlite") {
+          query = query.for("update");
+        }
         return await query;
       } catch (error) {
         throw this.handleQueryError(error, "select", table);
@@ -389,8 +759,12 @@ var DrizzleAdapter = class {
    * });
    * ```
    */
-  async selectOne(table, options) {
-    const results = await this.select(table, { ...options, limit: 1 });
+  async selectOne(table, options, executor) {
+    const results = await this.select(
+      table,
+      { ...options, limit: 1 },
+      executor
+    );
     return results.length > 0 ? results[0] : null;
   }
   /**
@@ -422,19 +796,22 @@ var DrizzleAdapter = class {
         const mappedData = this.mapDataToColumnNames(tableObj, data);
         const db = this.getDrizzle();
         const caps = this.getCapabilities();
-        if (caps.supportsReturning && options?.returning) {
-          const result2 = await db.insert(tableObj).values(mappedData).returning();
+        const returning = options?.returning;
+        const wantsReturning = returning != null && !(Array.isArray(returning) && returning.length === 0);
+        if (caps.supportsReturning && wantsReturning) {
+          const projection = this.buildColumnProjection(tableObj, returning);
+          const insertQuery = db.insert(tableObj).values(mappedData);
+          const result2 = await (projection ? insertQuery.returning(projection) : insertQuery.returning());
           return Array.isArray(result2) ? result2[0] : result2;
         }
         const result = await db.insert(tableObj).values(mappedData);
-        if (!caps.supportsReturning && options?.returning) {
-          if (data.id !== void 0) {
-            return await this.selectOne(table, {
-              where: {
-                and: [{ column: "id", op: "=", value: data.id }]
-              }
-            });
-          }
+        if (!caps.supportsReturning && wantsReturning && data.id !== void 0) {
+          return await this.selectOne(table, {
+            columns: returning === "*" ? void 0 : returning,
+            where: {
+              and: [{ column: "id", op: "=", value: data.id }]
+            }
+          });
         }
         return Array.isArray(result) ? result[0] : result;
       } catch (error) {
@@ -504,11 +881,11 @@ var DrizzleAdapter = class {
    * );
    * ```
    */
-  async update(table, data, where, options) {
+  async update(table, data, where, options, executor) {
     const tableObj = this.getTableObject(table);
     if (tableObj) {
       try {
-        const db = this.getDrizzle();
+        const db = executor ?? this.getDrizzle();
         const caps = this.getCapabilities();
         const mappedData = this.mapDataToColumnNames(tableObj, data);
         let query = db.update(tableObj).set(mappedData);
@@ -521,7 +898,7 @@ var DrizzleAdapter = class {
         }
         await query;
         if (!caps.supportsReturning && options?.returning) {
-          return await this.select(table, { where });
+          return await this.select(table, { where }, executor);
         }
         return [];
       } catch (error) {
@@ -534,6 +911,42 @@ var DrizzleAdapter = class {
       void 0
     );
   }
+  /**
+   * Update records in a table and report how many rows the statement affected.
+   *
+   * The count is the whole return value, mirroring `delete`. `update` cannot answer this: without
+   * `returning` it discards the driver's count, and WITH `returning` on a dialect that lacks
+   * RETURNING it re-SELECTs using the same WHERE — so a conditional update that just changed a
+   * column named in that WHERE reads back zero rows and a write that landed reports as unmatched.
+   * Reading the driver's own count has no second query to disagree with the first.
+   *
+   * 🔴 MySQL reports CHANGED rows, not matched rows: an UPDATE that matches a row but writes values
+   * identical to what it holds counts zero. A caller using this as a compare-and-set must therefore
+   * include a column the write always moves — a version bump, a timestamp with enough resolution —
+   * so that matched implies changed. Postgres (`rowCount`) and SQLite (`changes`) count matched
+   * rows and do not need the precaution, which is exactly why it cannot be dropped: the dialect
+   * where the distinction exists is the one with no RETURNING to fall back on.
+   */
+  async updateCount(table, data, where, executor) {
+    const tableObj = this.getTableObject(table);
+    if (tableObj) {
+      try {
+        const db = executor ?? this.getDrizzle();
+        const mappedData = this.mapDataToColumnNames(tableObj, data);
+        const statement = db.update(tableObj).set(mappedData);
+        const whereCondition = buildDrizzleWhere(tableObj, where);
+        const result = await (whereCondition ? statement.where(whereCondition) : statement);
+        return affectedRowCount(result);
+      } catch (error) {
+        throw this.handleQueryError(error, "update", table);
+      }
+    }
+    throw this.createDatabaseError(
+      "query",
+      `Table "${table}" not found in schema registry. Ensure setTableResolver() has been called during boot.`,
+      void 0
+    );
+  }
   /**
    * Delete records from a table.
    *
@@ -556,18 +969,18 @@ var DrizzleAdapter = class {
    * console.log(`Deleted ${count} users`);
    * ```
    */
-  async delete(table, where, _options) {
+  async delete(table, where, _options, executor) {
     const tableObj = this.getTableObject(table);
     if (tableObj) {
       try {
-        const db = this.getDrizzle();
+        const db = executor ?? this.getDrizzle();
         let query = db.delete(tableObj);
         const whereCondition = buildDrizzleWhere(tableObj, where);
         if (whereCondition) {
           query = query.where(whereCondition);
         }
         const result = await query;
-        return Array.isArray(result) ? result.length : result?.rowCount ?? result?.changes ?? 0;
+        return affectedRowCount(result);
       } catch (error) {
         throw this.handleQueryError(error, "delete", table);
       }
@@ -605,13 +1018,13 @@ var DrizzleAdapter = class {
    * });
    * ```
    */
-  async upsert(table, data, options) {
+  async upsert(table, data, options, executor) {
     const tableObj = this.getTableObject(table);
     if (tableObj) {
       try {
-        const db = this.getDrizzle();
+        const db = executor ?? this.getDrizzle();
         const caps = this.getCapabilities();
-        const columns = getTableColumns(tableObj);
+        const columns = getColumns(tableObj);
         const conflictTarget = options.conflictColumns.map((col) => columns[col]).filter(Boolean);
         const conflictSet = new Set(options.conflictColumns);
         const updateData = {};
@@ -636,17 +1049,21 @@ var DrizzleAdapter = class {
         }
         await query;
         if (options.conflictColumns.length && data[options.conflictColumns[0]] !== void 0) {
-          return await this.selectOne(table, {
-            where: {
-              and: [
-                {
-                  column: options.conflictColumns[0],
-                  op: "=",
-                  value: data[options.conflictColumns[0]]
-                }
-              ]
-            }
-          });
+          return await this.selectOne(
+            table,
+            {
+              where: {
+                and: [
+                  {
+                    column: options.conflictColumns[0],
+                    op: "=",
+                    value: data[options.conflictColumns[0]]
+                  }
+                ]
+              }
+            },
+            executor
+          );
         }
         return data;
       } catch (error) {
@@ -893,11 +1310,15 @@ var DrizzleAdapter = class {
           sql = `
             SELECT EXISTS (
               SELECT FROM information_schema.tables
-              WHERE table_schema = $1
+              WHERE table_schema = COALESCE($1, (
+                SELECT n.nspname FROM pg_class c
+                JOIN pg_namespace n ON n.oid = c.relnamespace
+                WHERE c.oid = to_regclass($2)
+              ))
               AND table_name = $2
             ) as exists
           `;
-          params.push(schema ?? "public", tableName);
+          params.push(schema ?? null, tableName);
           break;
         case "mysql":
           sql = `
@@ -972,7 +1393,7 @@ var DrizzleAdapter = class {
           break;
         case "mysql":
           sql = `
-            SELECT table_name
+            SELECT table_name AS table_name
             FROM information_schema.tables
             WHERE table_schema = DATABASE()
             AND table_type = 'BASE TABLE'