turbine-orm 0.18.0 → 0.19.1

package/dist/query/builder.js

@@ -30,6 +30,20 @@ function isWhereOperator(value) {
     const keys = Object.keys(value);
     return keys.length > 0 && keys.every((k) => OPERATOR_KEYS.has(k));
 }
+/**
+ * True for a *plain object literal* that reached an equality fallthrough
+ * without matching any known filter shape — the misspelled-operator case.
+ * Class instances (Buffer for bytea, Decimal wrappers, ...) are legitimate
+ * bind values and return false, as do arrays and Dates.
+ */
+function isUnmatchedPlainObject(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value) || value instanceof Date)
+        return false;
+    if (typeof Buffer !== 'undefined' && Buffer.isBuffer(value))
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
 /** Known atomic-update operator keys — used to detect operator objects vs plain JSON values */
 const UPDATE_OPERATOR_KEYS = new Set(['set', 'increment', 'decrement', 'multiply', 'divide']);
 /** Known JSONB operator keys */
@@ -1687,12 +1701,24 @@ export class QueryInterface {
      */
     resolveColumns(select, omit) {
         if (select) {
+            // An array here means a caller wrote `select: ['id', 'name']` (Drizzle/SQL
+            // style) instead of the object shape. Object.entries() would iterate the
+            // numeric indices and throw a cryptic `Unknown field "0"` — catch it early
+            // with an actionable message.
+            if (Array.isArray(select)) {
+                throw new ValidationError(`[turbine] "select" must be an object mapping field names to true ` +
+                    `(e.g. { id: true, name: true }), not an array.`);
+            }
             // Only include columns where value is true
             return Object.entries(select)
                 .filter(([, v]) => v)
                 .map(([k]) => this.toColumn(k));
         }
         if (omit) {
+            if (Array.isArray(omit)) {
+                throw new ValidationError(`[turbine] "omit" must be an object mapping field names to true ` +
+                    `(e.g. { createdAt: true }), not an array.`);
+            }
             // Include all columns except those where value is true
             const omitCols = new Set(Object.entries(omit)
                 .filter(([, v]) => v)
@@ -1896,6 +1922,16 @@ export class QueryInterface {
                 parts.push(`${key}:fts(${cfg})`);
                 continue;
             }
+            // Plain object literal that matched no filter shape — give it a
+            // fingerprint distinct from real equality. The build path throws for
+            // these on non-JSON columns; sharing `key:eq` would let a cache entry
+            // warmed by genuine equality serve the bad filter silently.
+            if (isUnmatchedPlainObject(value)) {
+                parts.push(`${key}:obj(${Object.keys(value)
+                    .sort()
+                    .join(',')})`);
+                continue;
+            }
             // Plain equality
             parts.push(`${key}:eq`);
         }
@@ -1935,6 +1971,11 @@ export class QueryInterface {
                 const modeStr = mode === 'insensitive' ? ':i' : '';
                 parts.push(`${key}:op(${opKeys.join(',')}${modeStr})`);
             }
+            else if (isUnmatchedPlainObject(value)) {
+                parts.push(`${key}:obj(${Object.keys(value)
+                    .sort()
+                    .join(',')})`);
+            }
             else {
                 parts.push(`${key}:eq`);
             }
@@ -2037,7 +2078,9 @@ export class QueryInterface {
                 this.collectOperatorParams(value, params);
                 continue;
             }
-            // Plain equality
+            // Plain equality — same strict validation as the build path, so a
+            // cache hit can never silently bind a misspelled-operator object.
+            this.assertBindableEqualityValue(rawColumn, value, this.getColumnPgType(rawColumn), this.table);
             params.push(value);
         }
     }
@@ -2046,7 +2089,7 @@ export class QueryInterface {
         const meta = this.schema.tables[targetTable];
         if (!meta)
             return;
-        for (const [_field, value] of Object.entries(subWhere)) {
+        for (const [field, value] of Object.entries(subWhere)) {
             if (value === undefined)
                 continue;
             if (value === null)
@@ -2055,6 +2098,8 @@ export class QueryInterface {
                 this.collectOperatorParams(value, params);
                 continue;
             }
+            const col = meta.columnMap[field] ?? camelToSnake(field);
+            this.assertBindableEqualityValue(col, value, this.pgTypeForColumn(meta, col), targetTable);
             params.push(value);
         }
     }
@@ -2182,13 +2227,11 @@ export class QueryInterface {
                     .sort();
                 subParts.push(`om=${omKeys.join(',')}`);
             }
-            // where shape (value-invariant)
+            // where shape (value-invariant, operator-shape-aware: `{title: 'x'}` and
+            // `{title: {contains: 'x'}}` emit different SQL so they must not share
+            // a fingerprint)
             if (opts.where) {
-                // Use a target-table QI if possible, or a simplified fingerprint
-                const wKeys = Object.keys(opts.where)
-                    .filter((k) => opts.where[k] !== undefined)
-                    .sort();
-                subParts.push(`w=${wKeys.join(',')}`);
+                subParts.push(`w=${this.fingerprintAliasWhere(opts.where)}`);
             }
             // orderBy shape
             if (opts.orderBy) {
@@ -2238,11 +2281,9 @@ export class QueryInterface {
         //   where params → limit param → nested-with params (always, both paths).
         if (relDef.type === 'manyToMany') {
             if (spec.where) {
-                for (const [, v] of Object.entries(spec.where)) {
-                    params.push(v);
-                }
+                this.collectAliasWhereParams(targetTable, targetMeta, spec.where, params);
             }
-            if (spec.limit) {
+            if (spec.limit !== undefined) {
                 params.push(Number(spec.limit));
             }
             if (spec.with) {
@@ -2255,7 +2296,9 @@ export class QueryInterface {
             }
             return;
         }
-        const willWrap = relDef.type === 'hasMany' && (spec.limit !== undefined || spec.orderBy !== undefined);
+        // Mirrors buildRelationSubquery's willWrap: `orderBy: {}` is treated as absent.
+        const hasOrder = spec.orderBy ? Object.values(spec.orderBy).some((dir) => dir !== undefined) : false;
+        const willWrap = relDef.type === 'hasMany' && (spec.limit !== undefined || hasOrder);
         // Non-wrapped path: nested relations BEFORE where/limit
         if (!willWrap && spec.with) {
             for (const [nestedRelName, nestedSpec] of Object.entries(spec.with)) {
@@ -2265,14 +2308,15 @@ export class QueryInterface {
                 this.collectRelationSubqueryParams(nestedRelDef, nestedSpec, params, 'alias', depth + 1);
             }
         }
-        // where params
+        // where params — mirrors buildAliasWhere push order
         if (spec.where) {
-            for (const [, v] of Object.entries(spec.where)) {
-                params.push(v);
-            }
+            this.collectAliasWhereParams(targetTable, targetMeta, spec.where, params);
         }
-        // limit param
-        if (spec.limit) {
+        // limit param — only hasMany parameterizes its limit (mirrors
+        // buildRelationSubquery). belongsTo/hasOne ignore limit (always LIMIT 1), so
+        // pushing one here would orphan a param and desync the collect path.
+        // `limit: 0` pushes (LIMIT 0 is honored), so check !== undefined.
+        if (relDef.type === 'hasMany' && spec.limit !== undefined) {
             params.push(Number(spec.limit));
         }
         // Wrapped path: nested relations AFTER where/limit (inside inner subquery)
@@ -2480,6 +2524,11 @@ export class QueryInterface {
                 andClauses.push(...opClauses);
                 continue;
             }
+            // Strict validation: a plain object literal that matched no known filter
+            // shape is almost always a misspelled operator (`startWith` for
+            // `startsWith`). The guard also runs on the cache-hit param-collect path
+            // (collectWhereParams) so a warmed SQL cache can never skip it.
+            this.assertBindableEqualityValue(rawColumn, value, this.getColumnPgType(rawColumn), this.table);
             // Plain equality
             params.push(value);
             andClauses.push(`${column} = ${this.p(params.length)}`);
@@ -2579,11 +2628,168 @@ export class QueryInterface {
                 conditions.push(...opClauses);
                 continue;
             }
+            this.assertBindableEqualityValue(col, value, this.pgTypeForColumn(meta, col), targetTable);
             params.push(value);
             conditions.push(`${qCol} = ${this.p(params.length)}`);
         }
         return conditions.length > 0 ? conditions.join(' AND ') : null;
     }
+    /**
+     * Resolve a column's Postgres type from an arbitrary table's metadata
+     * (relation targets, not just `this.table`).
+     */
+    pgTypeForColumn(meta, column) {
+        return meta.dialectTypes?.[column] ?? meta.pgTypes?.[column] ?? 'text';
+    }
+    /**
+     * Equality-fallthrough guard shared by every SQL-build path AND every
+     * cache-hit param-collect path. A plain object literal that matched no known
+     * filter shape on a non-JSON column is almost always a misspelled operator
+     * (`startWith` for `startsWith`); binding it as `col = $1` silently returns
+     * wrong rows. Class instances (Buffer for bytea, Decimal wrappers, ...) are
+     * legitimate bind values and pass through, as do objects on json/jsonb
+     * columns (object equality).
+     */
+    assertBindableEqualityValue(rawColumn, value, columnPgType, table) {
+        if (!isUnmatchedPlainObject(value))
+            return;
+        if (columnPgType === 'json' || columnPgType === 'jsonb')
+            return;
+        const badKeys = Object.keys(value);
+        throw new ValidationError(badKeys.length === 0
+            ? `[turbine] Empty filter object on "${rawColumn}" for table "${table}". ` +
+                `Provide a value or an operator like { gt: 1 }.`
+            : `[turbine] Unknown operator${badKeys.length > 1 ? 's' : ''} ` +
+                `${badKeys.map((k) => `"${k}"`).join(', ')} on "${rawColumn}" for table "${table}". ` +
+                `Supported operators: ${[...OPERATOR_KEYS].join(', ')}.`);
+    }
+    /**
+     * Build the user-supplied `where` filter of a relation `with` clause against
+     * the relation's table alias. Supports the same scalar surface as the
+     * top-level WHERE builder — equality, IS NULL, operator objects (incl.
+     * `mode: 'insensitive'`), and OR/AND/NOT combinators. Unknown operator
+     * objects throw via {@link assertBindableEqualityValue}.
+     *
+     * Param push order MUST mirror {@link collectAliasWhereParams} exactly, or
+     * cache hits and pipeline batching will desync.
+     */
+    buildAliasWhere(targetTable, targetMeta, alias, where, params) {
+        const clauses = [];
+        for (const [key, value] of Object.entries(where)) {
+            if (value === undefined)
+                continue;
+            if (key === 'OR' || key === 'AND') {
+                const arr = value;
+                if (!Array.isArray(arr) || arr.length === 0)
+                    continue;
+                const subs = arr
+                    .map((cond) => this.buildAliasWhere(targetTable, targetMeta, alias, cond, params))
+                    .filter((s) => s !== null)
+                    .map((s) => `(${s})`);
+                if (subs.length > 0)
+                    clauses.push(`(${subs.join(key === 'OR' ? ' OR ' : ' AND ')})`);
+                continue;
+            }
+            if (key === 'NOT') {
+                const sub = this.buildAliasWhere(targetTable, targetMeta, alias, value, params);
+                if (sub)
+                    clauses.push(`NOT (${sub})`);
+                continue;
+            }
+            const col = targetMeta.columnMap[key] ?? camelToSnake(key);
+            if (!targetMeta.allColumns.includes(col)) {
+                throw new ValidationError(`[turbine] Unknown column "${key}" in where for table "${targetTable}"`);
+            }
+            const qCol = `${alias}.${this.q(col)}`;
+            if (value === null) {
+                clauses.push(`${qCol} IS NULL`);
+                continue;
+            }
+            if (isWhereOperator(value)) {
+                clauses.push(...this.buildOperatorClauses(qCol, value, params));
+                continue;
+            }
+            this.assertBindableEqualityValue(col, value, this.pgTypeForColumn(targetMeta, col), targetTable);
+            params.push(value);
+            clauses.push(`${qCol} = ${this.p(params.length)}`);
+        }
+        return clauses.length > 0 ? clauses.join(' AND ') : null;
+    }
+    /** Mirrors {@link buildAliasWhere} param-push order for the cache-hit collect path. */
+    collectAliasWhereParams(targetTable, targetMeta, where, params) {
+        for (const [key, value] of Object.entries(where)) {
+            if (value === undefined)
+                continue;
+            if (key === 'OR' || key === 'AND') {
+                const arr = value;
+                if (!Array.isArray(arr) || arr.length === 0)
+                    continue;
+                for (const cond of arr) {
+                    this.collectAliasWhereParams(targetTable, targetMeta, cond, params);
+                }
+                continue;
+            }
+            if (key === 'NOT') {
+                this.collectAliasWhereParams(targetTable, targetMeta, value, params);
+                continue;
+            }
+            if (value === null)
+                continue;
+            if (isWhereOperator(value)) {
+                this.collectOperatorParams(value, params);
+                continue;
+            }
+            const col = targetMeta.columnMap[key] ?? camelToSnake(key);
+            this.assertBindableEqualityValue(col, value, this.pgTypeForColumn(targetMeta, col), targetTable);
+            params.push(value);
+        }
+    }
+    /**
+     * Value-invariant, shape-aware fingerprint for a relation `with` clause's
+     * `where` filter. Must distinguish every SQL shape {@link buildAliasWhere}
+     * can emit — equality vs null vs operator sets vs combinators — or two
+     * differently-shaped wheres would share one cached SQL string.
+     */
+    fingerprintAliasWhere(where) {
+        const keys = Object.keys(where)
+            .filter((k) => where[k] !== undefined)
+            .sort();
+        const parts = [];
+        for (const key of keys) {
+            const value = where[key];
+            if (key === 'OR' || key === 'AND') {
+                const arr = value;
+                if (!Array.isArray(arr) || arr.length === 0)
+                    continue;
+                parts.push(`${key}[${arr.map((c) => this.fingerprintAliasWhere(c)).join(',')}]`);
+                continue;
+            }
+            if (key === 'NOT') {
+                parts.push(`NOT(${this.fingerprintAliasWhere(value)})`);
+                continue;
+            }
+            if (value === null) {
+                parts.push(`${key}:null`);
+                continue;
+            }
+            if (isWhereOperator(value)) {
+                const opKeys = Object.keys(value)
+                    .filter((k) => k !== 'mode')
+                    .sort();
+                const mode = value.mode;
+                parts.push(`${key}:op(${opKeys.join(',')}${mode === 'insensitive' ? ':i' : ''})`);
+                continue;
+            }
+            if (isUnmatchedPlainObject(value)) {
+                parts.push(`${key}:obj(${Object.keys(value)
+                    .sort()
+                    .join(',')})`);
+                continue;
+            }
+            parts.push(`${key}:eq`);
+        }
+        return parts.join('&');
+    }
     /**
      * Build SQL clauses for a single operator object on a column.
      * Each operator key becomes its own clause, all ANDed together.
@@ -2663,7 +2869,8 @@ export class QueryInterface {
         return Object.entries(orderBy)
             .map(([key, dir]) => {
             if (meta && !(key in meta.columnMap)) {
-                throw new ValidationError(`Unknown column "${key}" in orderBy for table "${this.table}"`);
+                throw new ValidationError(`[turbine] Unknown field "${key}" in orderBy on table "${this.table}". ` +
+                    `Known fields: ${Object.keys(meta.columnMap).join(', ') || '(none)'}.`);
             }
             // Vector KNN ordering: { distance: { to, metric, direction? } }
             if (isVectorOrderBy(dir)) {
@@ -3029,7 +3236,11 @@ export class QueryInterface {
         // Determine if this hasMany will take the wrapped subquery path (LIMIT or ORDER BY).
         // When wrapping, nested relations are built in the wrapped path referencing innerAlias,
         // so we must NOT build them here (they would push orphaned params).
-        const willWrap = relDef.type === 'hasMany' && spec !== true && (spec.limit !== undefined || spec.orderBy !== undefined);
+        // An orderBy with no defined entries (`orderBy: {}`) is treated as absent —
+        // it must neither trigger the wrap (dropping nested relations) nor render a
+        // dangling `ORDER BY `. `limit: 0` is meaningful (LIMIT 0) and DOES wrap.
+        const relOrderEntries = spec !== true && spec.orderBy ? Object.entries(spec.orderBy).filter(([, dir]) => dir !== undefined) : [];
+        const willWrap = relDef.type === 'hasMany' && spec !== true && (spec.limit !== undefined || relOrderEntries.length > 0);
         // manyToMany takes a dedicated JOIN-through-junction path. Nested relations,
         // where, orderBy, and select/omit are handled there (the target alias is the
         // row source, exactly like hasMany), so short-circuit before the hasMany logic.
@@ -3057,14 +3268,14 @@ export class QueryInterface {
         const qTarget = this.q(targetTable);
         // Build ORDER BY for json_agg
         let orderClause = '';
-        if (spec !== true && spec.orderBy) {
-            const orders = Object.entries(spec.orderBy)
+        if (relOrderEntries.length > 0) {
+            const orders = relOrderEntries
                 .map(([k, dir]) => {
                 const col = camelToSnake(k);
                 if (!targetMeta.allColumns.includes(col)) {
                     throw new ValidationError(`[turbine] Unknown column "${k}" in orderBy for table "${targetTable}"`);
                 }
-                const safeDir = dir.toLowerCase() === 'desc' ? 'DESC' : 'ASC';
+                const safeDir = String(dir).toLowerCase() === 'desc' ? 'DESC' : 'ASC';
                 return `${alias}.${this.q(col)} ${safeDir}`;
             })
                 .join(', ');
@@ -3081,20 +3292,21 @@ export class QueryInterface {
         else {
             whereClause = this.dialect.buildCorrelation(alias, relDef.foreignKey, qParent, relDef.referenceKey);
         }
-        // Additional filters — properly parameterized
+        // Additional filters — full scalar where surface (equality, null, operator
+        // objects, OR/AND/NOT), properly parameterized against this alias.
         if (spec !== true && spec.where) {
-            for (const [k, v] of Object.entries(spec.where)) {
-                const col = camelToSnake(k);
-                if (!targetMeta.allColumns.includes(col)) {
-                    throw new ValidationError(`[turbine] Unknown column "${k}" in where for table "${targetTable}"`);
-                }
-                params.push(v);
-                whereClause += ` AND ${alias}.${this.q(col)} = ${this.p(params.length)}`;
-            }
-        }
-        // LIMIT
+            const extra = this.buildAliasWhere(targetTable, targetMeta, alias, spec.where, params);
+            if (extra)
+                whereClause += ` AND ${extra}`;
+        }
+        // LIMIT — only meaningful for hasMany. A belongsTo / hasOne subquery returns
+        // a single row (literal `LIMIT 1` below), so a `spec.limit` here must NOT push
+        // a parameter: doing so orphans an untyped `$N` that the SQL never references,
+        // which Postgres rejects with "could not determine data type of parameter $N"
+        // (and shifts every later placeholder by one). To-one relations ignore limit.
+        // `limit: 0` is honored (LIMIT 0 → empty array), so check !== undefined.
         let limitClause = '';
-        if (spec !== true && spec.limit) {
+        if (relDef.type === 'hasMany' && spec !== true && spec.limit !== undefined) {
             params.push(Number(spec.limit));
             limitClause = ` LIMIT ${this.p(params.length)}`;
         }
@@ -3188,35 +3400,33 @@ export class QueryInterface {
         let whereClause = sourceKeys
             .map((jcol, i) => `${jalias}.${this.q(jcol)} = ${qParent}.${this.q(refKeys[i])}`)
             .join(' AND ');
-        // ORDER BY on the target rows
+        // ORDER BY on the target rows. `orderBy: {}` (no defined entries) is
+        // treated as absent — it must not render a dangling `ORDER BY `.
+        const relOrderEntries = spec !== true && spec.orderBy ? Object.entries(spec.orderBy).filter(([, dir]) => dir !== undefined) : [];
         let orderClause = '';
-        if (spec !== true && spec.orderBy) {
-            const orders = Object.entries(spec.orderBy)
+        if (relOrderEntries.length > 0) {
+            const orders = relOrderEntries
                 .map(([k, dir]) => {
                 const col = camelToSnake(k);
                 if (!targetMeta.allColumns.includes(col)) {
                     throw new ValidationError(`[turbine] Unknown column "${k}" in orderBy for table "${targetTable}"`);
                 }
-                const safeDir = dir.toLowerCase() === 'desc' ? 'DESC' : 'ASC';
+                const safeDir = String(dir).toLowerCase() === 'desc' ? 'DESC' : 'ASC';
                 return `${talias}.${this.q(col)} ${safeDir}`;
             })
                 .join(', ');
             orderClause = ` ORDER BY ${orders}`;
         }
-        // Additional WHERE filters on the target — properly parameterized.
+        // Additional WHERE filters on the target — full scalar where surface,
+        // properly parameterized against the target alias.
         if (spec !== true && spec.where) {
-            for (const [k, v] of Object.entries(spec.where)) {
-                const col = camelToSnake(k);
-                if (!targetMeta.allColumns.includes(col)) {
-                    throw new ValidationError(`[turbine] Unknown column "${k}" in where for table "${targetTable}"`);
-                }
-                params.push(v);
-                whereClause += ` AND ${talias}.${this.q(col)} = ${this.p(params.length)}`;
-            }
+            const extra = this.buildAliasWhere(targetTable, targetMeta, talias, spec.where, params);
+            if (extra)
+                whereClause += ` AND ${extra}`;
         }
-        // LIMIT
+        // LIMIT — `limit: 0` is honored (LIMIT 0 → empty array)
         let limitClause = '';
-        if (spec !== true && spec.limit) {
+        if (spec !== true && spec.limit !== undefined) {
             params.push(Number(spec.limit));
             limitClause = ` LIMIT ${this.p(params.length)}`;
         }

package/dist/query/index.d.ts

@@ -5,7 +5,7 @@
  * `import { … } from './query/index.js'` is a drop-in replacement for the
  * former monolithic `import { … } from './query.js'`.
  */
-export type { AggregateArgs, AggregateResult, ArrayFilter, ConnectOrCreateOp, CountArgs, CreateArgs, CreateManyArgs, DeleteArgs, DeleteManyArgs, FieldResult, FindManyArgs, FindManyStreamArgs, FindUniqueArgs, GroupByArgs, JsonFilter, NestedCreateOp, NestedUpdateOp, OmitResult, OrderByClause, OrderDirection, QueryResult, RelationDescriptor, RelationFilter, SelectResult, TextSearchFilter, TypedWithClause, UpdateArgs, UpdateInput, UpdateManyArgs, UpdateOperatorInput, UpsertArgs, VectorDistanceFilter, VectorFilter, VectorMetric, VectorOrderBy, VectorOrderByDistance, WhereClause, WhereOperator, WhereValue, WithClause, WithOptions, WithResult, } from './types.js';
+export type { AggregateArgs, AggregateResult, ArrayFilter, ConnectOrCreateOp, CountArgs, CreateArgs, CreateManyArgs, DeleteArgs, DeleteManyArgs, FieldResult, FindManyArgs, FindManyStreamArgs, FindUniqueArgs, GroupByArgs, HavingClause, JsonFilter, NestedCreateOp, NestedUpdateOp, OmitResult, OrderByClause, OrderDirection, QueryResult, RelationDescriptor, RelationFilter, SelectResult, TextSearchFilter, TypedWithClause, UpdateArgs, UpdateInput, UpdateManyArgs, UpdateOperatorInput, UpsertArgs, VectorDistanceFilter, VectorFilter, VectorMetric, VectorOrderBy, VectorOrderByDistance, WhereClause, WhereOperator, WhereValue, WithClause, WithOptions, WithResult, } from './types.js';
 export type { BuiltStatement, BulkInsertStatementInput, ColumnDefinitionInput, ColumnTypeInput, CreateIndexStatementInput, CreateTableStatementInput, Dialect, InsertStatementInput, UpsertStatementInput, } from '../dialect.js';
 export { postgresDialect } from '../dialect.js';
 export type { SqlCacheEntry } from './utils.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "turbine-orm",
-  "version": "0.18.0",
+  "version": "0.19.1",
   "description": "Postgres-native TypeScript ORM — runs on Neon, Vercel Postgres, Cloudflare, Supabase. Streaming cursors, typed errors, single-query nested relations. One dependency, no WASM engine",
   "type": "module",
   "exports": {
@@ -42,7 +42,7 @@
   "sideEffects": false,
   "scripts": {
     "prebuild": "npm run gen:studio",
-    "build": "tsc && tsc --project tsconfig.cjs.json && echo '{\"type\":\"commonjs\"}' > dist/cjs/package.json",
+    "build": "rm -rf dist && tsc && tsc --project tsconfig.cjs.json && echo '{\"type\":\"commonjs\"}' > dist/cjs/package.json",
     "dev": "tsc --watch",
     "typecheck": "tsc --noEmit --project tsconfig.test.json",
     "generate": "tsx src/cli/index.ts generate",
@@ -50,7 +50,7 @@
     "examples": "tsx examples/examples.ts",
     "dogfood": "tsx examples/dogfood.ts",
     "test": "tsx --test --test-concurrency=1 src/test/*.test.ts",
-    "test:unit": "tsx --test src/test/schema-builder.test.ts src/test/errors.test.ts src/test/stress.test.ts src/test/migrate.test.ts src/test/update-operators.test.ts src/test/empty-where-guard.test.ts src/test/cli.test.ts src/test/serverless.test.ts src/test/pipeline.test.ts src/test/pipeline-submittable.test.ts src/test/with-inference.test.ts src/test/operator-validation.test.ts src/test/unlimited-warning.test.ts src/test/generate-relations.test.ts src/test/stream-and-parse.test.ts src/test/sql-cache.test.ts src/test/dialect.test.ts src/test/studio.test.ts src/test/sql-injection.test.ts src/test/cli-flags.test.ts src/test/cockroachdb-adapter.test.ts src/test/yugabytedb-adapter.test.ts src/test/pg-compat.test.ts src/test/relation-filter-validation.test.ts src/test/client-coverage.test.ts src/test/schema-diff.test.ts src/test/composite-fk.test.ts src/test/retry.test.ts src/test/text-search.test.ts src/test/optimistic-lock.test.ts src/test/sql-safety-property.test.ts src/test/nested-write.test.ts src/test/nested-write-update-upsert.test.ts src/test/cursor-pagination.test.ts src/test/client-branches.test.ts src/test/is-isNot-filter.test.ts src/test/event-emitter.test.ts src/test/observe.test.ts",
+    "test:unit": "tsx --test src/test/schema-builder.test.ts src/test/errors.test.ts src/test/stress.test.ts src/test/migrate.test.ts src/test/update-operators.test.ts src/test/empty-where-guard.test.ts src/test/cli.test.ts src/test/serverless.test.ts src/test/pipeline.test.ts src/test/pipeline-submittable.test.ts src/test/with-inference.test.ts src/test/operator-validation.test.ts src/test/unlimited-warning.test.ts src/test/generate-relations.test.ts src/test/stream-and-parse.test.ts src/test/sql-cache.test.ts src/test/dialect.test.ts src/test/studio.test.ts src/test/sql-injection.test.ts src/test/cli-flags.test.ts src/test/cockroachdb-adapter.test.ts src/test/yugabytedb-adapter.test.ts src/test/pg-compat.test.ts src/test/relation-filter-validation.test.ts src/test/client-coverage.test.ts src/test/schema-diff.test.ts src/test/composite-fk.test.ts src/test/retry.test.ts src/test/text-search.test.ts src/test/optimistic-lock.test.ts src/test/sql-safety-property.test.ts src/test/nested-write.test.ts src/test/nested-write-update-upsert.test.ts src/test/cursor-pagination.test.ts src/test/client-branches.test.ts src/test/is-isNot-filter.test.ts src/test/event-emitter.test.ts src/test/observe.test.ts src/test/relation-limit-param.test.ts src/test/where-guard-cache-and-relation-where.test.ts",
     "test:coverage": "c8 tsx --test --test-concurrency=1 src/test/*.test.ts",
     "lint": "biome check src/",
     "lint:fix": "biome check --write src/",