turbine-orm 0.80.0 → 0.81.0

package/dist/query/writes.js

@@ -12,7 +12,7 @@
  */
 import { NotFoundError, OptimisticLockError, UnsupportedFeatureError, ValidationError } from '../errors.js';
 import { camelToSnake, snakeToCamel } from '../schema.js';
-import { assertMutationWhereIdentifiesOneRow, expandCompoundUniqueWhere } from './compound-unique.js';
+import { assertMutationWhereIdentifiesOneRow, expandCompoundUniqueWhere, upsertWhereMatchesCreate, } from './compound-unique.js';
 import { isUnmatchedPlainObject, UPDATE_OPERATOR_KEYS } from './filters.js';
 import { resolveSkipGlobalFilters, resolveUnsafeFlag } from './types.js';
 import { canonicalWriteEntries, coerceTemporalValue, resolveColumnName } from './utils.js';
@@ -541,6 +541,35 @@ export function buildDelete(qi, args, projection) {
             : undefined,
     };
 }
+export function upsertLookupReason(qi, args) {
+    const where = (args.where ?? {});
+    const create = (args.create ?? {});
+    if (!upsertWhereMatchesCreate(qi.tableMeta, where, create))
+        return 'where-differs';
+    if (writeEntries(qi, (args.update ?? {})).length === 0)
+        return 'empty-update';
+    if (!qi.dialect.supportsUpsertUpdateWhere) {
+        qi.currentSkip = resolveSkipGlobalFilters(args.skipGlobalFilters);
+        const filter = whereMod.resolveGlobalFilter(qi, qi.table);
+        if (filter && whereMod.buildRenderedRefWhere(qi, qi.table, qi.tableMeta, qi.q(qi.table), filter, [])) {
+            return 'global-filter';
+        }
+    }
+    return null;
+}
+/** The refusal `buildUpsert` raises for each reason, naming the way forward. */
+function upsertStatementRefusal(qi, reason, where) {
+    const call = 'Call `upsert()` unbatched: it looks the row up by `where` first.';
+    if (reason === 'global-filter') {
+        return new UnsupportedFeatureError(`a batched upsert on "${qi.table}", which has a global filter,`, qi.dialect.name, `Its upsert statement cannot carry the filter. ${call} Or pass \`skipGlobalFilters: UNSAFE\`.`);
+    }
+    const keys = Object.keys(where).filter((k) => where[k] !== undefined);
+    return new ValidationError(`A batched upsert on "${qi.table}" cannot be one statement: ` +
+        (reason === 'empty-update'
+            ? 'its `update` is empty. '
+            : `\`where\` (${keys.join(', ')}) does not carry \`create\`'s values, which are what one statement matches on. `) +
+        call);
+}
 export function buildUpsert(qi, args, projection) {
     assertWritable(qi, 'upsert');
     assertNoGeneratedColumns(qi, args.create, 'upsert');
@@ -565,6 +594,11 @@ export function buildUpsert(qi, args, projection) {
     // `allowFullTableScan: UNSAFE`, which is not an option on `UpsertArgs` at
     // all, so borrowing it here would name a way out that does not exist.
     assertMutationWhereIdentifiesOneRow(qi.tableMeta, qi.table, upsertWhere, 'upsert');
+    // `upsert()` never reaches here with a reason (it looks the row up instead),
+    // so this refuses only a batched upsert, which has no round trip to spare.
+    const lookupReason = upsertLookupReason(qi, args);
+    if (lookupReason)
+        throw upsertStatementRefusal(qi, lookupReason, upsertWhere);
     // Build the INSERT part from create data
     const createEntries = writeEntries(qi, args.create);
     const columns = createEntries.map(([k]) => qi.toSqlColumn(k));
@@ -598,20 +632,6 @@ export function buildUpsert(qi, args, projection) {
     // globally filtered table at parse time (42702), insert path included.
     let updateWhere;
     const upsertFilter = whereMod.resolveGlobalFilter(qi, qi.table);
-    if (upsertFilter && !qi.dialect.supportsUpsertUpdateWhere) {
-        // MySQL's `ON DUPLICATE KEY UPDATE` has no predicate slot and SQL Server's
-        // MERGE cannot take the builder's column references there, so on those
-        // engines the filter used to be DROPPED from the conflict update, silently.
-        // A tenant-scoped upsert whose key matched another tenant's row updated
-        // that row. Refused instead, when the filter would compile to anything:
-        // the global-filter contract is that it scopes every update, and an
-        // upsert that cannot honour it must not run as if it did.
-        if (whereMod.buildRenderedRefWhere(qi, qi.table, qi.tableMeta, qi.q(qi.table), upsertFilter, [])) {
-            throw new UnsupportedFeatureError(`upsert on "${qi.table}", which has a global filter,`, qi.dialect.name, "This engine's upsert statement cannot carry the filter on its conflict update, so it could update a row " +
-                'the filter hides. Use findUnique, then update or create, inside $transaction; or pass ' +
-                '`skipGlobalFilters: UNSAFE` if the upsert is meant to reach every row.');
-        }
-    }
     if (qi.dialect.supportsUpsertUpdateWhere) {
         const gf = upsertFilter;
         if (gf) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "turbine-orm",
-  "version": "0.80.0",
+  "version": "0.81.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).",
@@ -213,7 +213,7 @@
     "@types/pg": "^8.11.11",
     "@zvndev/powdb-client": "^0.20.0",
     "@zvndev/powdb-embedded": "^0.20.0",
-    "c8": "^11.0.0",
+    "c8": "^12.0.0",
     "esbuild": "^0.28.2",
     "husky": "^9.1.7",
     "lint-staged": "^17.0.8",

package/skills/turbine-orm/SKILL.md

@@ -242,9 +242,12 @@ where: { guildId: 4, batchRef: 'WB-0007' }              // equivalent
 
 `update`, `delete` and `upsert` each require a `where` that identifies one row,
 by the same rule as `findUnique`, and anything else is `TURBINE_E003` naming the
-keys that would work. For an upsert the `where` **is** the `ON CONFLICT` target,
-so a non-unique predicate is refused rather than sent. Use `updateMany` and
-`deleteMany` for "every row matching a filter".
+keys that would work. For an upsert the `where` names the row to update, and is
+the `ON CONFLICT` target when `create` carries the same values, so a non-unique
+predicate is refused rather than sent. When `create` does not carry them (a
+`create` that leaves `id` to its sequence, say), `upsert` looks the row up by
+`where` first, inside a transaction. Use `updateMany` and `deleteMany` for
+"every row matching a filter".
 
 ## `distinct`