@nextlyhq/adapter-drizzle 0.0.2-alpha.5 → 0.0.2-alpha.51

package/dist/index.cjs

@@ -4,7 +4,7 @@ var drizzleOrm = require('drizzle-orm');
 
 // src/adapter.ts
 function buildDrizzleWhere(table, where) {
-  const columns = drizzleOrm.getTableColumns(table);
+  const columns = drizzleOrm.getColumns(table);
   return processWhereClause(columns, where);
 }
 function processWhereClause(columns, where) {
@@ -108,6 +108,21 @@ function createDatabaseError(options) {
 }
 
 // src/adapter.ts
+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
@@ -136,6 +151,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
@@ -175,6 +229,107 @@ 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;
+  }
+  /**
+   * 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 = drizzleOrm.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)
   // ============================================================
@@ -328,12 +483,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,
@@ -344,7 +500,7 @@ var DrizzleAdapter = class {
           }
         }
         if (options?.orderBy?.length) {
-          const columns = drizzleOrm.getTableColumns(tableObj);
+          const columns = drizzleOrm.getColumns(tableObj);
           const orderClauses = options.orderBy.map((o) => {
             const col = columns[o.column];
             if (!col) return void 0;
@@ -360,6 +516,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);
@@ -391,8 +557,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;
   }
   /**
@@ -424,19 +594,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) {
@@ -506,11 +679,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);
@@ -523,7 +696,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) {
@@ -558,18 +731,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);
       }
@@ -607,13 +780,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 = drizzleOrm.getTableColumns(tableObj);
+        const columns = drizzleOrm.getColumns(tableObj);
         const conflictTarget = options.conflictColumns.map((col) => columns[col]).filter(Boolean);
         const conflictSet = new Set(options.conflictColumns);
         const updateData = {};
@@ -638,17 +811,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) {
@@ -974,7 +1151,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'