turbine-orm 0.52.0 → 0.53.0

package/dist/query/types.d.ts

@@ -718,23 +718,29 @@ export interface CountArgs<T, R extends object = {}> {
     skipGlobalFilters?: SkipGlobalFilters;
 }
 /**
- * Numeric comparison operators usable inside a `having` filter. A bare number
+ * Comparison operators usable inside a `having` aggregate filter. A bare value
  * is shorthand for equality (`COUNT(*) = $n`); the operator object supports
- * range and inequality comparisons. Mirrors the numeric subset of
+ * range and inequality comparisons. Mirrors the comparison subset of
  * {@link WhereOperator} so the same SQL machinery can be reused.
+ *
+ * `V` is the operand type: `number` for `_sum` / `_avg` / `_count`, the
+ * column's own type for `_min` / `_max` (those return a stored cell, so
+ * `MIN("title") > 'm'` is as valid as `MIN("views") > 10`).
  */
-export interface HavingNumericOperator {
-    equals?: number;
-    not?: number;
-    gt?: number;
-    gte?: number;
-    lt?: number;
-    lte?: number;
-    in?: number[];
-    notIn?: number[];
+export interface HavingComparisonOperator<V = number> {
+    equals?: V;
+    not?: V;
+    gt?: V;
+    gte?: V;
+    lt?: V;
+    lte?: V;
+    in?: V[];
+    notIn?: V[];
 }
-/** A single having predicate value: a bare number (equality) or an operator object. */
-export type HavingFilter = number | HavingNumericOperator;
+/** The number-operand spelling, kept as the historical public name. */
+export type HavingNumericOperator = HavingComparisonOperator<number>;
+/** A single having predicate value: a bare value (equality) or an operator object. */
+export type HavingFilter<V = number> = V | HavingComparisonOperator<V>;
 /**
  * Per-field aggregate filters inside a {@link HavingClause}. Each aggregate
  * function maps to a {@link HavingFilter} comparison on that field.
@@ -742,33 +748,52 @@ export type HavingFilter = number | HavingNumericOperator;
  * @example
  *   viewCount: { _sum: { gt: 100 }, _avg: { lte: 50 } }
  */
-export interface HavingAggregateFilter {
+export interface HavingAggregateFilter<V = unknown> {
     _sum?: HavingFilter;
     _avg?: HavingFilter;
-    _min?: HavingFilter;
-    _max?: HavingFilter;
+    _min?: HavingFilter<V>;
+    _max?: HavingFilter<V>;
     _count?: HavingFilter;
 }
+/**
+ * One field entry of a {@link HavingClause}. Following Prisma, a field accepts
+ * BOTH an aggregate filter (`{ _sum: { gt: 100 } }`) and a scalar filter on the
+ * grouped value itself (`{ not: null }`, `{ in: ['a', 'b'] }`, or a bare value
+ * as equality shorthand), including both in the same object, which are ANDed.
+ *
+ * A scalar filter is only legal on a column listed in `by`: the group's value
+ * is constant within the group, so it compiles into HAVING against the bare
+ * group key. On any other column it throws {@link ValidationError} E003, since
+ * a non-grouped column cannot be referenced in HAVING at all.
+ */
+export type HavingFieldFilter<V = unknown> = (HavingAggregateFilter<V> & WhereOperator<V>) | WhereValue<V>;
 /**
  * HAVING clause for `groupBy`, filters whole groups by their aggregate values
- * (the SQL `HAVING` clause). Follows Prisma's shape: each aggregable field maps
- * to a {@link HavingAggregateFilter} (`field → aggregate → operator → value`),
- * and the special top-level `_count` key (no field) filters on `COUNT(*)`.
+ * and by the grouped values themselves (the SQL `HAVING` clause). Follows
+ * Prisma's shape: each field maps to a {@link HavingFieldFilter}, the special
+ * top-level `_count` key (no field) filters on `COUNT(*)`, and `AND` / `OR` /
+ * `NOT` combine predicates at any depth.
  *
- * Implemented as a mapped type so the special `_count` key can carry a
- * {@link HavingFilter} while every entity field carries a
- * {@link HavingAggregateFilter}, without the index-signature conflict an
- * intersection type would produce when `T` is a broad `Record<string, unknown>`.
+ * Implemented as a mapped type so the special keys can carry their own value
+ * types while every entity field carries a {@link HavingFieldFilter}, without
+ * the index-signature conflict an intersection type would produce when `T` is
+ * a broad `Record<string, unknown>`.
  *
  * @example
  *   // groups with more than 5 rows whose summed viewCount is at least 100
  *   having: { _count: { gt: 5 }, viewCount: { _sum: { gte: 100 } } }
+ * @example
+ *   // by: ['typeId'] , drop the NULL group, keep busy groups
+ *   having: { typeId: { not: null }, _count: { gt: 1 } }
  */
 export type HavingClause<T> = {
     /** Filter on `COUNT(*)` for the whole group. */
     _count?: HavingFilter;
+    AND?: HavingClause<T> | HavingClause<T>[];
+    OR?: HavingClause<T>[];
+    NOT?: HavingClause<T> | HavingClause<T>[];
 } & {
-    [K in keyof T & string]?: HavingAggregateFilter;
+    [K in keyof T & string]?: HavingFieldFilter<T[K]>;
 };
 /**
  * A JSON-path group key in {@link GroupByArgs.by}: groups by the value

package/dist/query/utils.d.ts

@@ -23,6 +23,36 @@ export declare function quoteIdent(name: string): string;
  * unless `key` is an OWN enumerable/non-enumerable property.
  */
 export declare function ownLookup<T>(map: Record<string, T>, key: string): T | undefined;
+/** The metadata a key needs to be resolved to a column. `TableMetadata` fits. */
+export interface ColumnNameSource {
+    columnMap: Record<string, string>;
+    reverseColumnMap?: Record<string, string>;
+    allColumns?: string[];
+}
+/**
+ * Resolve a user-supplied key to its unquoted column name, or `undefined` when
+ * the key names no column on the table.
+ *
+ * THE key-resolution rule, in one place. `QueryInterface.toColumn` is this
+ * function plus the E003 throw, so every SQL builder resolves keys through it,
+ * and the value-side passes (write coercion, the `updatedAt` injector, the
+ * nested-write foreign-key merge) call it directly rather than re-deriving the
+ * rule. They used to read `columnMap` alone, which knows only the FIELD
+ * spelling, so a key spelled as the snake_case COLUMN, which the SQL builders
+ * accept and which is the natural spelling on an introspected schema, produced
+ * correct SQL with an unprocessed value: byte-identical statement, silently
+ * different bound param.
+ *
+ * The rule: the field map first, else `camelToSnake(key)` accepted ONLY when
+ * that name is a real column. `camelToSnake` is idempotent on an already-snake
+ * string, which is what makes the column spelling legal; arbitrary strings
+ * still fail to resolve, so identifier validation is unchanged.
+ *
+ * Prototype-safe: both maps are plain objects, so a key like "constructor" or
+ * "__proto__" would otherwise return an inherited member and pass for a column
+ * name (see {@link ownLookup}).
+ */
+export declare function resolveColumnName(meta: ColumnNameSource, key: string): string | undefined;
 /**
  * Escape single quotes for use as string keys in json_build_object().
  * Doubles single quotes per SQL quoting rules.

package/dist/query/utils.js

@@ -4,7 +4,7 @@
  * Standalone utility functions and classes used by the query builder.
  */
 import pg from 'pg';
-import { localDateTimeKind, timeOfDayKind } from '../schema.js';
+import { camelToSnake, localDateTimeKind, timeOfDayKind } from '../schema.js';
 // ---------------------------------------------------------------------------
 // Identifier quoting, prevents SQL injection via table/column names
 // ---------------------------------------------------------------------------
@@ -32,6 +32,40 @@ export function quoteIdent(name) {
 export function ownLookup(map, key) {
     return Object.hasOwn(map, key) ? map[key] : undefined;
 }
+/**
+ * Resolve a user-supplied key to its unquoted column name, or `undefined` when
+ * the key names no column on the table.
+ *
+ * THE key-resolution rule, in one place. `QueryInterface.toColumn` is this
+ * function plus the E003 throw, so every SQL builder resolves keys through it,
+ * and the value-side passes (write coercion, the `updatedAt` injector, the
+ * nested-write foreign-key merge) call it directly rather than re-deriving the
+ * rule. They used to read `columnMap` alone, which knows only the FIELD
+ * spelling, so a key spelled as the snake_case COLUMN, which the SQL builders
+ * accept and which is the natural spelling on an introspected schema, produced
+ * correct SQL with an unprocessed value: byte-identical statement, silently
+ * different bound param.
+ *
+ * The rule: the field map first, else `camelToSnake(key)` accepted ONLY when
+ * that name is a real column. `camelToSnake` is idempotent on an already-snake
+ * string, which is what makes the column spelling legal; arbitrary strings
+ * still fail to resolve, so identifier validation is unchanged.
+ *
+ * Prototype-safe: both maps are plain objects, so a key like "constructor" or
+ * "__proto__" would otherwise return an inherited member and pass for a column
+ * name (see {@link ownLookup}).
+ */
+export function resolveColumnName(meta, key) {
+    const mapped = ownLookup(meta.columnMap, key);
+    if (mapped)
+        return mapped;
+    const snake = camelToSnake(key);
+    if (meta.reverseColumnMap && ownLookup(meta.reverseColumnMap, snake))
+        return snake;
+    if (meta.allColumns?.includes(snake))
+        return snake;
+    return undefined;
+}
 /**
  * Escape single quotes for use as string keys in json_build_object().
  * Doubles single quotes per SQL quoting rules.

package/dist/query/warn-registry.d.ts

@@ -58,6 +58,13 @@ export declare const WARN_NS: {
     readonly unorderedPage: "unorderedPage";
     /** PowDB `emitLinks` DDL skips (name/column collision, endpoint drift). */
     readonly powdbLinks: "powdbLinks";
+    /**
+     * A key on the object passed as `TurbineConfig` that is not part of the
+     * config surface (client.ts `warnUnknownConfigKeys`). Keyed on the unknown
+     * key name, so a process that builds many clients from the same misspelled
+     * config says it once.
+     */
+    readonly unknownConfigKey: "unknownConfigKey";
     /**
      * `relationLoadStrategy: 'flatten'` was asked for but a relation stayed on the
      * correlated-subquery path (relations.ts `planFlattenWith`, builder.ts

package/dist/query/warn-registry.js

@@ -93,6 +93,13 @@ export const WARN_NS = {
     unorderedPage: 'unorderedPage',
     /** PowDB `emitLinks` DDL skips (name/column collision, endpoint drift). */
     powdbLinks: 'powdbLinks',
+    /**
+     * A key on the object passed as `TurbineConfig` that is not part of the
+     * config surface (client.ts `warnUnknownConfigKeys`). Keyed on the unknown
+     * key name, so a process that builds many clients from the same misspelled
+     * config says it once.
+     */
+    unknownConfigKey: 'unknownConfigKey',
     /**
      * `relationLoadStrategy: 'flatten'` was asked for but a relation stayed on the
      * correlated-subquery path (relations.ts `planFlattenWith`, builder.ts

package/dist/query/writes.d.ts

@@ -112,7 +112,11 @@ export declare function piiFields(_qi: BuilderCtx, meta: TableMetadata): string[
  * `Date` and lands in UTC on every engine.
  *
  * An explicit value always wins, including an explicit `null`: naming the
- * column is a statement of intent.
+ * column is a statement of intent. "Named" is decided by resolving each data
+ * key to its COLUMN, not by matching the field spelling: the SET list resolves
+ * the caller's key the same way, so a key spelled as the snake_case column used
+ * to be missed here and the injected field assigned the same column a second
+ * time (`SET "updated_at" = $1, "updated_at" = $2`, PostgreSQL 42701).
  */
 export declare function applyUpdatedAtColumns(qi: BuilderCtx, data: Record<string, unknown>): Record<string, unknown>;
 export declare function writeReturningColumns(qi: BuilderCtx): ReturningSelection;

package/dist/query/writes.js

@@ -14,7 +14,7 @@ import { NotFoundError, OptimisticLockError, UnsupportedFeatureError, Validation
 import { camelToSnake, snakeToCamel } from '../schema.js';
 import { expandCompoundUniqueWhere } from './compound-unique.js';
 import { isUnmatchedPlainObject, UPDATE_OPERATOR_KEYS } from './filters.js';
-import { coerceTemporalValue, ownLookup } from './utils.js';
+import { coerceTemporalValue, resolveColumnName } from './utils.js';
 import * as whereMod from './where.js';
 /**
  * Normalize one `data` value before it is bound as a write param.
@@ -42,10 +42,14 @@ export function coerceWriteValue(qi, key, value) {
     // Cheap shape check first: the common path costs one check and no lookup.
     if (!(value instanceof Date) && !Array.isArray(value))
         return value;
-    // Non-throwing column resolution: this runs on the cache-HIT param-collect
-    // path too, where an unknown key must not turn into a different error than
-    // the build path already raises.
-    const column = ownLookup(qi.tableMeta.columnMap, key);
+    // THE key-resolution rule, shared with `toColumn` (the SQL side of this very
+    // statement) so the two can never disagree about which column a key names:
+    // resolving through `columnMap` alone missed the snake_case COLUMN spelling
+    // that the SQL builders accept, so those writes bound an unprocessed value
+    // under an identical statement. Non-throwing, because this also runs on the
+    // cache-HIT param-collect path, where an unknown key must not turn into a
+    // different error than the build path already raises.
+    const column = resolveColumnName(qi.tableMeta, key);
     if (!column)
         return value;
     // Metadata generated by an older Turbine still carries per-column types
@@ -694,22 +698,43 @@ export function piiFields(_qi, meta) {
  * `Date` and lands in UTC on every engine.
  *
  * An explicit value always wins, including an explicit `null`: naming the
- * column is a statement of intent.
+ * column is a statement of intent. "Named" is decided by resolving each data
+ * key to its COLUMN, not by matching the field spelling: the SET list resolves
+ * the caller's key the same way, so a key spelled as the snake_case column used
+ * to be missed here and the injected field assigned the same column a second
+ * time (`SET "updated_at" = $1, "updated_at" = $2`, PostgreSQL 42701).
  */
 export function applyUpdatedAtColumns(qi, data) {
     const tagged = qi.tableMeta.columns.filter((c) => c.updatedAt);
     if (tagged.length === 0)
         return data;
+    const named = namedColumns(qi.tableMeta, data);
     let out = null;
     const now = new Date();
     for (const col of tagged) {
-        if (Object.hasOwn(data, col.field) && data[col.field] !== undefined)
+        if (named.has(col.name))
             continue;
         out ??= { ...data };
         out[col.field] = now;
     }
     return out ?? data;
 }
+/**
+ * The set of COLUMNS a `data` object names, under any accepted spelling of each
+ * key. A key set to `undefined` names nothing (see {@link definedKeys}), and a
+ * key that resolves to no column is left to the SQL builder's own E003.
+ */
+function namedColumns(meta, data) {
+    const out = new Set();
+    for (const key of Object.keys(data)) {
+        if (data[key] === undefined)
+            continue;
+        const column = resolveColumnName(meta, key);
+        if (column)
+            out.add(column);
+    }
+    return out;
+}
 export function writeReturningColumns(qi) {
     const piiCols = piiColumns(qi, qi.tableMeta);
     if (piiCols.size === 0)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "turbine-orm",
-  "version": "0.52.0",
+  "version": "0.53.0",
   "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": "Each subpath declares its types PER CONDITION. A single shared top-level \"types\" resolves to the ESM declarations for `require` too, which is TS1479 (\"is an ES module ... cannot be require()d\") for any CJS consumer on moduleResolution node16/nodenext. The require condition points at dist/cjs, which ships its own {\"type\":\"commonjs\"} package.json, so those declarations are CJS declarations. Gated in CI by publint + @arethetypeswrong/cli + a real .cts consumer typecheck (see the package-types job in ci.yml).",