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

package/dist/index.d.cts

@@ -1,7 +1,7 @@
-export { D as DrizzleAdapter, T as TransactionCrudDelegator, a as TransactionCrudForwarders } from './adapter-BeMxQXZs.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-DhMuYiIm.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, T as TransactionCrudDelegator, a as TransactionCrudForwarders } from './adapter-BRvxUZrS.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-BnT96HFp.js';
+import './migration-R06fsTrz.js';
 import './schema-BIQ0YQZ_.js';
 import './error-BrdknH2s.js';
 

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { getColumns, desc, asc, sql, and, or, not, notBetween, between, isNotNull, isNull, notInArray, inArray, ilike, like, 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) {
@@ -567,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)) {
@@ -575,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)
@@ -806,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,