@nextlyhq/adapter-drizzle 0.0.2-alpha.35 → 0.0.2-alpha.39

package/dist/{adapter-nvlxFkF-.d.cts → adapter-BXgnu6Ao.d.cts}

@@ -1,5 +1,6 @@
+import { AnyRelations } from 'drizzle-orm';
 import { S as SupportedDialect, a as SqlParam, T as TableResolver } from './core-CVO7WYDj.cjs';
-import { T as TransactionContext, e as TransactionOptions, D as DatabaseCapabilities, P as PoolStats, S as SelectOptions, I as InsertOptions, W as WhereClause, U as UpdateOptions, f as DeleteOptions, g as UpsertOptions, a as Migration, d as MigrationResult } from './migration-BbO5meEV.cjs';
+import { T as TransactionContext, e as TransactionOptions, D as DatabaseCapabilities, P as PoolStats, S as SelectOptions, I as InsertOptions, W as WhereClause, U as UpdateOptions, f as DeleteOptions, g as UpsertOptions, a as Migration, d as MigrationResult } from './migration-YLYiVdVc.cjs';
 import { T as TableDefinition, C as CreateTableOptions, D as DropTableOptions, A as AlterTableOperation, a as AlterTableOptions } from './schema-BDn8WfSL.cjs';
 import { D as DatabaseErrorKind, a as DatabaseError } from './error-um1d_3Uo.cjs';
 
@@ -16,53 +17,6 @@ import { D as DatabaseErrorKind, a as DatabaseError } from './error-um1d_3Uo.cjs
  * @packageDocumentation
  */
 
-/**
- * Abstract base class for database adapters.
- *
- * @remarks
- * All dialect-specific adapters must extend this class and implement the abstract methods.
- * Default implementations are provided for CRUD operations, which can be overridden for
- * optimization or dialect-specific behavior.
- *
- * ## Required Implementations
- *
- * Subclasses must implement:
- * - `dialect` - Database dialect identifier
- * - `connect()` - Establish database connection
- * - `disconnect()` - Close database connection
- * - `executeQuery()` - Execute raw SQL query
- * - `transaction()` - Execute operations within a transaction
- * - `getCapabilities()` - Report database feature support
- *
- * ## Optional Overrides
- *
- * Subclasses can override default CRUD methods for optimization:
- * - `select()`, `selectOne()` - Custom query optimization
- * - `insert()`, `insertMany()` - Bulk insert optimization
- * - `update()`, `delete()` - Custom update/delete logic
- * - `upsert()` - Dialect-specific upsert syntax
- *
- * @example
- * ```typescript
- * export class PostgresAdapter extends DrizzleAdapter {
- *   readonly dialect = 'postgresql' as const;
- *
- *   async connect() {
- *     this.pool = new Pool({ connectionString: this.config.url });
- *     // ... connection logic
- *   }
- *
- *   async executeQuery<T>(sql: string, params?: SqlParam[]) {
- *     const result = await this.pool.query(sql, params);
- *     return result.rows as T[];
- *   }
- *
- *   // ... other required methods
- * }
- * ```
- *
- * @public
- */
 declare abstract class DrizzleAdapter {
     /**
      * Database dialect identifier.
@@ -136,17 +90,18 @@ declare abstract class DrizzleAdapter {
      * - Consistent error handling
      * - Proper connection pooling
      *
-     * @param schema - Optional schema object for typed queries
+     * @param relations - Optional drizzle v1 relations config (defineRelations
+     *   output) that enables the typed relational query API on the instance
      * @returns Raw Drizzle ORM database instance
      *
      * @example
      * ```typescript
      * // For legacy code that needs direct Drizzle access
-     * const db = adapter.getDrizzle(mySchemas);
+     * const db = adapter.getDrizzle(myRelations); // defineRelations output
      * const result = await db.insert(users).values({ ... }).returning();
      * ```
      */
-    abstract getDrizzle<T = unknown>(schema?: Record<string, unknown>): T;
+    abstract getDrizzle<T = unknown>(relations?: AnyRelations): T;
     /**
      * Table resolver for looking up Drizzle table objects by name.
      * When set, CRUD methods use Drizzle's query API instead of raw SQL.
@@ -174,6 +129,44 @@ declare abstract class DrizzleAdapter {
      * because they match the DB column names. This method maps them to the JS names Drizzle expects.
      */
     protected mapDataToColumnNames(tableObj: unknown, data: Record<string, unknown>): Record<string, unknown>;
+    /**
+     * 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.
+     */
+    protected mapKeysToSqlColumns(tableObj: unknown, data: Record<string, unknown>): Record<string, unknown>;
+    /**
+     * 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.
+     */
+    protected mapColumnNamesToSql(tableObj: unknown, names: string[]): string[];
+    /**
+     * 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.
+     */
+    protected mapRowKeysToJs<T = unknown>(tableObj: unknown, row: T): T;
+    /**
+     * 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.
+     */
+    protected buildColumnProjection(tableObj: unknown, names: string[] | "*" | undefined): Record<string, unknown> | undefined;
     /**
      * Check if the adapter is currently connected.
      *
@@ -286,7 +279,7 @@ declare abstract class DrizzleAdapter {
      * });
      * ```
      */
-    select<T = unknown>(table: string, options?: SelectOptions): Promise<T[]>;
+    select<T = unknown>(table: string, options?: SelectOptions, executor?: unknown): Promise<T[]>;
     /**
      * Select a single record from a table.
      *
@@ -307,7 +300,7 @@ declare abstract class DrizzleAdapter {
      * });
      * ```
      */
-    selectOne<T = unknown>(table: string, options?: SelectOptions): Promise<T | null>;
+    selectOne<T = unknown>(table: string, options?: SelectOptions, executor?: unknown): Promise<T | null>;
     /**
      * Insert a single record into a table.
      *
@@ -378,7 +371,7 @@ declare abstract class DrizzleAdapter {
      * );
      * ```
      */
-    update<T = unknown>(table: string, data: Record<string, unknown>, where: WhereClause, options?: UpdateOptions): Promise<T[]>;
+    update<T = unknown>(table: string, data: Record<string, unknown>, where: WhereClause, options?: UpdateOptions, executor?: unknown): Promise<T[]>;
     /**
      * Delete records from a table.
      *
@@ -401,7 +394,7 @@ declare abstract class DrizzleAdapter {
      * console.log(`Deleted ${count} users`);
      * ```
      */
-    delete(table: string, where: WhereClause, _options?: DeleteOptions): Promise<number>;
+    delete(table: string, where: WhereClause, _options?: DeleteOptions, executor?: unknown): Promise<number>;
     /**
      * Upsert (INSERT or UPDATE) a record.
      *
@@ -429,7 +422,7 @@ declare abstract class DrizzleAdapter {
      * });
      * ```
      */
-    upsert<T = unknown>(table: string, data: Record<string, unknown>, options: UpsertOptions): Promise<T>;
+    upsert<T = unknown>(table: string, data: Record<string, unknown>, options: UpsertOptions, executor?: unknown): Promise<T>;
     /**
      * Run pending migrations.
      *

package/dist/{adapter-BxJVtttb.d.ts → adapter-CWTncnCq.d.ts}

@@ -1,5 +1,6 @@
+import { AnyRelations } from 'drizzle-orm';
 import { S as SupportedDialect, a as SqlParam, T as TableResolver } from './core-CVO7WYDj.js';
-import { T as TransactionContext, e as TransactionOptions, D as DatabaseCapabilities, P as PoolStats, S as SelectOptions, I as InsertOptions, W as WhereClause, U as UpdateOptions, f as DeleteOptions, g as UpsertOptions, a as Migration, d as MigrationResult } from './migration-Qe70wDOC.js';
+import { T as TransactionContext, e as TransactionOptions, D as DatabaseCapabilities, P as PoolStats, S as SelectOptions, I as InsertOptions, W as WhereClause, U as UpdateOptions, f as DeleteOptions, g as UpsertOptions, a as Migration, d as MigrationResult } from './migration-CzQxJoz1.js';
 import { T as TableDefinition, C as CreateTableOptions, D as DropTableOptions, A as AlterTableOperation, a as AlterTableOptions } from './schema-BIQ0YQZ_.js';
 import { D as DatabaseErrorKind, a as DatabaseError } from './error-um1d_3Uo.js';
 
@@ -16,53 +17,6 @@ import { D as DatabaseErrorKind, a as DatabaseError } from './error-um1d_3Uo.js'
  * @packageDocumentation
  */
 
-/**
- * Abstract base class for database adapters.
- *
- * @remarks
- * All dialect-specific adapters must extend this class and implement the abstract methods.
- * Default implementations are provided for CRUD operations, which can be overridden for
- * optimization or dialect-specific behavior.
- *
- * ## Required Implementations
- *
- * Subclasses must implement:
- * - `dialect` - Database dialect identifier
- * - `connect()` - Establish database connection
- * - `disconnect()` - Close database connection
- * - `executeQuery()` - Execute raw SQL query
- * - `transaction()` - Execute operations within a transaction
- * - `getCapabilities()` - Report database feature support
- *
- * ## Optional Overrides
- *
- * Subclasses can override default CRUD methods for optimization:
- * - `select()`, `selectOne()` - Custom query optimization
- * - `insert()`, `insertMany()` - Bulk insert optimization
- * - `update()`, `delete()` - Custom update/delete logic
- * - `upsert()` - Dialect-specific upsert syntax
- *
- * @example
- * ```typescript
- * export class PostgresAdapter extends DrizzleAdapter {
- *   readonly dialect = 'postgresql' as const;
- *
- *   async connect() {
- *     this.pool = new Pool({ connectionString: this.config.url });
- *     // ... connection logic
- *   }
- *
- *   async executeQuery<T>(sql: string, params?: SqlParam[]) {
- *     const result = await this.pool.query(sql, params);
- *     return result.rows as T[];
- *   }
- *
- *   // ... other required methods
- * }
- * ```
- *
- * @public
- */
 declare abstract class DrizzleAdapter {
     /**
      * Database dialect identifier.
@@ -136,17 +90,18 @@ declare abstract class DrizzleAdapter {
      * - Consistent error handling
      * - Proper connection pooling
      *
-     * @param schema - Optional schema object for typed queries
+     * @param relations - Optional drizzle v1 relations config (defineRelations
+     *   output) that enables the typed relational query API on the instance
      * @returns Raw Drizzle ORM database instance
      *
      * @example
      * ```typescript
      * // For legacy code that needs direct Drizzle access
-     * const db = adapter.getDrizzle(mySchemas);
+     * const db = adapter.getDrizzle(myRelations); // defineRelations output
      * const result = await db.insert(users).values({ ... }).returning();
      * ```
      */
-    abstract getDrizzle<T = unknown>(schema?: Record<string, unknown>): T;
+    abstract getDrizzle<T = unknown>(relations?: AnyRelations): T;
     /**
      * Table resolver for looking up Drizzle table objects by name.
      * When set, CRUD methods use Drizzle's query API instead of raw SQL.
@@ -174,6 +129,44 @@ declare abstract class DrizzleAdapter {
      * because they match the DB column names. This method maps them to the JS names Drizzle expects.
      */
     protected mapDataToColumnNames(tableObj: unknown, data: Record<string, unknown>): Record<string, unknown>;
+    /**
+     * 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.
+     */
+    protected mapKeysToSqlColumns(tableObj: unknown, data: Record<string, unknown>): Record<string, unknown>;
+    /**
+     * 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.
+     */
+    protected mapColumnNamesToSql(tableObj: unknown, names: string[]): string[];
+    /**
+     * 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.
+     */
+    protected mapRowKeysToJs<T = unknown>(tableObj: unknown, row: T): T;
+    /**
+     * 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.
+     */
+    protected buildColumnProjection(tableObj: unknown, names: string[] | "*" | undefined): Record<string, unknown> | undefined;
     /**
      * Check if the adapter is currently connected.
      *
@@ -286,7 +279,7 @@ declare abstract class DrizzleAdapter {
      * });
      * ```
      */
-    select<T = unknown>(table: string, options?: SelectOptions): Promise<T[]>;
+    select<T = unknown>(table: string, options?: SelectOptions, executor?: unknown): Promise<T[]>;
     /**
      * Select a single record from a table.
      *
@@ -307,7 +300,7 @@ declare abstract class DrizzleAdapter {
      * });
      * ```
      */
-    selectOne<T = unknown>(table: string, options?: SelectOptions): Promise<T | null>;
+    selectOne<T = unknown>(table: string, options?: SelectOptions, executor?: unknown): Promise<T | null>;
     /**
      * Insert a single record into a table.
      *
@@ -378,7 +371,7 @@ declare abstract class DrizzleAdapter {
      * );
      * ```
      */
-    update<T = unknown>(table: string, data: Record<string, unknown>, where: WhereClause, options?: UpdateOptions): Promise<T[]>;
+    update<T = unknown>(table: string, data: Record<string, unknown>, where: WhereClause, options?: UpdateOptions, executor?: unknown): Promise<T[]>;
     /**
      * Delete records from a table.
      *
@@ -401,7 +394,7 @@ declare abstract class DrizzleAdapter {
      * console.log(`Deleted ${count} users`);
      * ```
      */
-    delete(table: string, where: WhereClause, _options?: DeleteOptions): Promise<number>;
+    delete(table: string, where: WhereClause, _options?: DeleteOptions, executor?: unknown): Promise<number>;
     /**
      * Upsert (INSERT or UPDATE) a record.
      *
@@ -429,7 +422,7 @@ declare abstract class DrizzleAdapter {
      * });
      * ```
      */
-    upsert<T = unknown>(table: string, data: Record<string, unknown>, options: UpsertOptions): Promise<T>;
+    upsert<T = unknown>(table: string, data: Record<string, unknown>, options: UpsertOptions, executor?: unknown): Promise<T>;
     /**
      * Run pending migrations.
      *

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
@@ -175,6 +190,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 +444,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 +461,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;
@@ -391,8 +508,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 +545,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 +630,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 +647,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 +682,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 +731,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 +762,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 +1102,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'