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

package/dist/index.d.cts

@@ -1,7 +1,7 @@
-export { D as DrizzleAdapter } from './adapter-BG7MnOUw.cjs';
+export { D as DrizzleAdapter, T as TransactionCrudDelegator, a as TransactionCrudForwarders } from './adapter-C6ENLDau.cjs';
 export { T as TableResolver } from './core-CVO7WYDj.cjs';
 import 'drizzle-orm';
-import './migration-BUc56kip.cjs';
+import './migration-B6AmjCQ1.cjs';
 import './schema-BDn8WfSL.cjs';
 import './error-BrdknH2s.cjs';
 

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-export { D as DrizzleAdapter } from './adapter-DjPoLjBK.js';
+export { D as DrizzleAdapter, T as TransactionCrudDelegator, a as TransactionCrudForwarders } from './adapter-D4GM1VAZ.js';
 export { T as TableResolver } from './core-CVO7WYDj.js';
 import 'drizzle-orm';
-import './migration-Bj84e15B.js';
+import './migration-R06fsTrz.js';
 import './schema-BIQ0YQZ_.js';
 import './error-BrdknH2s.js';
 

package/dist/index.mjs

@@ -1,6 +1,17 @@
-import { getColumns, desc, asc, and, or, not, like, notBetween, between, isNotNull, isNull, notInArray, inArray, ilike, lte, gte, lt, gt, ne, eq } from 'drizzle-orm';
+import { getColumns, count, desc, asc, sql, and, or, not, notBetween, between, isNotNull, isNull, notInArray, inArray, ilike, like, lte, gte, lt, gt, ne, eq } from 'drizzle-orm';
 
 // src/adapter.ts
+function buildDrizzleOrderBy(columns, orderBy) {
+  if (!orderBy?.length) return [];
+  return orderBy.flatMap((spec) => {
+    const col = columns[spec.column];
+    if (!col) return [];
+    const direction = spec.direction === "desc" ? desc(col) : asc(col);
+    if (spec.nulls === void 0) return [direction];
+    const isNull2 = sql`${col} is null`;
+    return [spec.nulls === "last" ? asc(isNull2) : desc(isNull2), direction];
+  });
+}
 function buildDrizzleWhere(table, where) {
   const columns = getColumns(table);
   return processWhereClause(columns, where);
@@ -36,13 +47,26 @@ function processWhereClause(columns, where) {
       parts.push(not(notCondition));
     }
   }
-  if (parts.length === 0) return void 0;
+  if (parts.length === 0) {
+    if (namesABranch(where)) {
+      throw new Error(
+        `Where clause produced no condition: ${JSON.stringify(where)}. Every branch resolved to nothing, which would match every row. Pass {} to mean "no filter".`
+      );
+    }
+    return void 0;
+  }
   if (parts.length === 1) return parts[0];
   return and(...parts);
 }
 function isWhereCondition(item) {
   return "column" in item && "op" in item;
 }
+function namesABranch(where) {
+  return Boolean(where.and?.length || where.or?.length || where.not);
+}
+function containsPattern(value) {
+  return `%${value.replace(/[!%_]/g, (character) => `!${character}`)}%`;
+}
 function buildCondition(columns, cond) {
   const column = columns[cond.column];
   if (!column) {
@@ -81,12 +105,37 @@ function buildCondition(columns, cond) {
     case "NOT BETWEEN":
       return notBetween(col, cond.value, cond.valueTo);
     case "CONTAINS":
-      return like(col, `%${String(cond.value)}%`);
+      return sql`${col} like ${containsPattern(String(cond.value))} escape '!'`;
     default:
       throw new Error(`Unsupported operator: ${cond.op}`);
   }
 }
 
+// src/transaction-forwarders.ts
+function createTransactionForwarders(delegator, txDb) {
+  return {
+    select: async (table, options) => {
+      return delegator.select(table, options, txDb());
+    },
+    selectOne: async (table, options) => {
+      return delegator.selectOne(table, options, txDb());
+    },
+    update: async (table, data, where, options) => {
+      return delegator.update(table, data, where, options, txDb());
+    },
+    updateCount: async (table, data, where) => {
+      return delegator.updateCount(table, data, where, txDb());
+    },
+    delete: async (table, where, options) => {
+      return delegator.delete(table, where, options, txDb());
+    },
+    upsert: async (table, data, options) => {
+      return delegator.upsert(table, data, options, txDb());
+    },
+    getDrizzle: () => txDb()
+  };
+}
+
 // src/types/error.ts
 function isDatabaseError(error) {
   return typeof error === "object" && error !== null && "kind" in error && typeof error.kind === "string";
@@ -518,6 +567,23 @@ var DrizzleAdapter = class {
     if (names == null || names === "*" || !tableObj || typeof tableObj !== "object") {
       return void 0;
     }
+    const { projection } = this.resolveColumns(tableObj, names);
+    return Object.keys(projection).length ? projection : void 0;
+  }
+  /**
+   * The requested column names split into what this table has and what it does not.
+   *
+   * One resolution, reported both ways, because two callers need different halves
+   * of the same answer: a projection drops what it cannot find, while a distinct
+   * count has to REFUSE it. Resolving twice would let the two disagree about what
+   * "found" means — the SQL-name alias below is exactly the kind of detail a
+   * second implementation gets wrong — and the count would then reject a column
+   * the projection happily uses.
+   *
+   * Both spellings resolve: a caller may name the Drizzle property or the SQL
+   * column, and either maps to the same projection key.
+   */
+  resolveColumns(tableObj, names) {
     const cols = getColumns(tableObj);
     const byAnyName = {};
     for (const [jsName, col] of Object.entries(cols)) {
@@ -526,11 +592,13 @@ var DrizzleAdapter = class {
       if (typeof sqlName === "string") byAnyName[sqlName] = { jsName, col };
     }
     const projection = {};
+    const unresolved = [];
     for (const name of names) {
       const hit = byAnyName[name];
       if (hit) projection[hit.jsName] = hit.col;
+      else unresolved.push(name);
     }
-    return Object.keys(projection).length ? projection : void 0;
+    return { projection, unresolved };
   }
   // ============================================================
   // Connection Status (Default implementations, can override)
@@ -702,12 +770,10 @@ var DrizzleAdapter = class {
           }
         }
         if (options?.orderBy?.length) {
-          const columns = getColumns(tableObj);
-          const orderClauses = options.orderBy.map((o) => {
-            const col = columns[o.column];
-            if (!col) return void 0;
-            return o.direction === "desc" ? desc(col) : asc(col);
-          }).filter(Boolean);
+          const orderClauses = buildDrizzleOrderBy(
+            getColumns(tableObj),
+            options.orderBy
+          );
           if (orderClauses.length) {
             query = query.orderBy(...orderClauses);
           }
@@ -759,6 +825,93 @@ var DrizzleAdapter = class {
    * });
    * ```
    */
+  /** The registered table object, or a refusal naming what is missing. */
+  requireTableObject(table) {
+    const tableObj = this.getTableObject(table);
+    if (tableObj) return tableObj;
+    throw this.createDatabaseError(
+      "query",
+      `Table "${table}" not found in schema registry. Ensure setTableResolver() has been called during boot.`,
+      void 0
+    );
+  }
+  /**
+   * The columns a distinct count groups by, or `undefined` for a row count.
+   *
+   * 🔴 EVERY named column must resolve, not merely one of them. A `distinctOn`
+   * naming no column this table has would fall through to a row count, and one
+   * naming a valid column beside a misspelled or since-removed column would
+   * count distinct over a NARROWER key than the caller asked for. Both answer a
+   * different question than the one asked, silently; the second is the worse of
+   * the two, because a subset key groups more rows together and so UNDERCOUNTS,
+   * which reads as a plausible number rather than as a fault. Refused here,
+   * where the mistake was made, rather than surfacing as a wrong figure.
+   */
+  countProjection(tableObj, table, options) {
+    const distinctOn = options?.distinctOn;
+    if (!distinctOn?.length) return void 0;
+    const { projection, unresolved } = this.resolveColumns(
+      tableObj,
+      distinctOn
+    );
+    if (unresolved.length > 0) {
+      throw this.createDatabaseError(
+        "query",
+        `distinctOn names ${unresolved.length === 1 ? "a column" : "columns"} that do not exist on "${table}": ${unresolved.join(", ")}`,
+        void 0
+      );
+    }
+    return projection;
+  }
+  /**
+   * `COUNT(*)` over a `SELECT DISTINCT` subquery.
+   *
+   * Its own function because it is a genuinely different query from the plain
+   * count rather than a variation on one, and because building both inline made
+   * the public method a chain of decisions the complexity gate objected to
+   * before a reader would have.
+   */
+  async countDistinctRows(db, tableObj, projection, where) {
+    const inner = db.selectDistinct(projection).from(tableObj).$dynamic();
+    const distinctRows = where ? inner.where(where) : inner;
+    const [row] = await db.select({ value: count() }).from(distinctRows.as("nextly_distinct"));
+    return Number(row?.value ?? 0);
+  }
+  /** `COUNT(*)` over the table itself. */
+  async countAllRows(db, tableObj, where) {
+    const base = db.select({ value: count() }).from(tableObj).$dynamic();
+    const [row] = await (where ? base.where(where) : base);
+    return Number(row?.value ?? 0);
+  }
+  /**
+   * How many rows match, or how many DISTINCT combinations of some columns do.
+   *
+   * The data layer had no count at all: collection totals go through
+   * `countEntries`, an access-controlled path built for collection tables, and
+   * nothing could count a system table. A caller wanting one selected the rows
+   * and measured the array, which transfers every row to learn a number and
+   * cannot be bounded without making the number wrong.
+   *
+   * 🔴 `distinctOn` compiles to `COUNT(*)` over a `SELECT DISTINCT` SUBQUERY,
+   * never to `COUNT(DISTINCT a, b)`. The inline form is not portable and fails
+   * in the direction that is hardest to notice -- MySQL accepts it, PostgreSQL
+   * needs a row constructor, and SQLite rejects it outright with "wrong number
+   * of arguments to function count()" -- so a query written against one engine
+   * is a syntax error on another. The subquery is the single form all three
+   * accept, and building it here rather than at each call site is what keeps
+   * the answer identical per dialect.
+   */
+  async count(table, options, executor) {
+    const tableObj = this.requireTableObject(table);
+    try {
+      const db = executor ?? this.getDrizzle();
+      const where = options?.where ? buildDrizzleWhere(tableObj, options.where) : void 0;
+      const projection = this.countProjection(tableObj, table, options);
+      return projection ? await this.countDistinctRows(db, tableObj, projection, where) : await this.countAllRows(db, tableObj, where);
+    } catch (error) {
+      throw this.handleQueryError(error, "count", table);
+    }
+  }
   async selectOne(table, options, executor) {
     const results = await this.select(
       table,
@@ -1303,11 +1456,11 @@ var DrizzleAdapter = class {
    */
   async tableExists(tableName, schema) {
     try {
-      let sql;
+      let sql3;
       const params = [];
       switch (this.dialect) {
         case "postgresql":
-          sql = `
+          sql3 = `
             SELECT EXISTS (
               SELECT FROM information_schema.tables
               WHERE table_schema = COALESCE($1, (
@@ -1321,7 +1474,7 @@ var DrizzleAdapter = class {
           params.push(schema ?? null, tableName);
           break;
         case "mysql":
-          sql = `
+          sql3 = `
             SELECT COUNT(*) as count
             FROM information_schema.tables
             WHERE table_schema = DATABASE()
@@ -1330,7 +1483,7 @@ var DrizzleAdapter = class {
           params.push(tableName);
           break;
         case "sqlite":
-          sql = `
+          sql3 = `
             SELECT COUNT(*) as count
             FROM sqlite_master
             WHERE type = 'table'
@@ -1346,7 +1499,7 @@ var DrizzleAdapter = class {
           );
       }
       const results = await this.executeQuery(
-        sql,
+        sql3,
         params
       );
       if (results.length === 0) {
@@ -1378,11 +1531,11 @@ var DrizzleAdapter = class {
    */
   async listTables(schema) {
     try {
-      let sql;
+      let sql3;
       const params = [];
       switch (this.dialect) {
         case "postgresql":
-          sql = `
+          sql3 = `
             SELECT table_name
             FROM information_schema.tables
             WHERE table_schema = $1
@@ -1392,7 +1545,7 @@ var DrizzleAdapter = class {
           params.push(schema ?? "public");
           break;
         case "mysql":
-          sql = `
+          sql3 = `
             SELECT table_name AS table_name
             FROM information_schema.tables
             WHERE table_schema = DATABASE()
@@ -1401,7 +1554,7 @@ var DrizzleAdapter = class {
           `;
           break;
         case "sqlite":
-          sql = `
+          sql3 = `
             SELECT name as table_name
             FROM sqlite_master
             WHERE type = 'table'
@@ -1417,7 +1570,7 @@ var DrizzleAdapter = class {
           );
       }
       const results = await this.executeQuery(
-        sql,
+        sql3,
         params
       );
       return results.map((row) => row.table_name);
@@ -1473,30 +1626,64 @@ var DrizzleAdapter = class {
     });
   }
   /**
-   * Handle query errors and convert to DatabaseError.
+   * Helper to create transaction context CRUD forwarding methods.
+   *
+   * @param txDb - Thunk returning the transaction-bound Drizzle executor
+   * @returns Object providing forwarded CRUD and getDrizzle methods
+   *
+   * @protected
+   */
+  createTransactionForwarders(txDb) {
+    return createTransactionForwarders(this, txDb);
+  }
+  /**
+   * Classify an error into a DatabaseError.
    *
    * @remarks
-   * Protected helper for consistent error handling across CRUD operations.
-   * Subclasses can override to add dialect-specific error classification.
+   * Subclasses can override this method to add dialect-specific error code classification.
    *
    * @param error - Original error
-   * @param operation - Operation that failed
-   * @param table - Table name
+   * @param sql - SQL statement that caused the error (optional)
    * @returns DatabaseError instance
    *
    * @protected
    */
-  handleQueryError(error, operation, table) {
+  classifyError(error, sql3) {
     if (isDatabaseError(error)) {
       return error;
     }
     const errorMessage = error instanceof Error ? error.message : String(error);
     return this.createDatabaseError(
       "query",
-      `${operation} operation failed on table '${table}': ${errorMessage}`,
+      sql3 ? `Query failed: ${errorMessage}` : errorMessage,
       error instanceof Error ? error : void 0
     );
   }
+  /**
+   * Handle query errors and convert to DatabaseError.
+   *
+   * @remarks
+   * Protected helper for consistent error handling across CRUD operations.
+   * Delegates to `classifyError` and attaches operation and table context if not present.
+   * Subclasses override `classifyError` to provide dialect-specific error code classification.
+   *
+   * @param error - Original error
+   * @param operation - Operation that failed
+   * @param table - Table name
+   * @returns DatabaseError instance
+   *
+   * @protected
+   */
+  handleQueryError(error, operation, table) {
+    const dbError = this.classifyError(error);
+    if (!dbError.message.includes(operation)) {
+      dbError.message = `${operation} operation failed on table '${table}': ${dbError.message}`;
+    }
+    if (!dbError.table) {
+      dbError.table = table;
+    }
+    return dbError;
+  }
 };
 var ALLOWED_DEFAULT_SQL_EXPRESSIONS = /* @__PURE__ */ new Set([
   "current_timestamp",