turbine-orm 0.31.0 → 0.32.0

package/dist/cjs/powql.js

@@ -74,6 +74,7 @@ const node_crypto_1 = require("node:crypto");
 const errors_js_1 = require("./errors.js");
 const nested_write_js_1 = require("./nested-write.js");
 const powdb_js_1 = require("./powdb.js");
+const filters_js_1 = require("./query/filters.js");
 const utils_js_1 = require("./query/utils.js");
 const schema_js_1 = require("./schema.js");
 /**
@@ -511,7 +512,22 @@ class PowqlInterface {
             return '';
         const parts = keys.map(([field, dir]) => {
             if (dir && typeof dir === 'object') {
-                throw new errors_js_1.UnsupportedFeatureError('vector / distance ordering', 'PowDB', `field "${field}"`);
+                // Name the actual feature in the refusal — a pick-row ordering
+                // reported as "vector / distance ordering" sends users hunting for
+                // pgvector docs. All object-valued orderings stay E017 on PowDB.
+                const o = dir;
+                const feature = (0, filters_js_1.isRelationPickOrderBy)(dir)
+                    ? 'relation pick-row ordering'
+                    : 'distance' in o
+                        ? 'vector / distance ordering'
+                        : Array.isArray(o.path)
+                            ? 'JSON-path ordering'
+                            : '_count' in o
+                                ? 'relation _count ordering'
+                                : 'sort' in o || 'nulls' in o
+                                    ? 'NULLS placement / sort-spec ordering'
+                                    : 'object-valued ordering';
+                throw new errors_js_1.UnsupportedFeatureError(feature, 'PowDB', `field "${field}"`);
             }
             return `${this.ref(field)} ${dir === 'desc' ? 'desc' : 'asc'}`;
         });
@@ -1155,6 +1171,27 @@ class PowqlInterface {
     }
     async groupBy(args) {
         return this.withMiddleware('groupBy', args, async () => {
+            // The SQL-only groupBy extensions (DISTINCT ON row source, JSON-path
+            // group keys / aggregate targets) have no PowQL equivalent: refuse
+            // clearly instead of emitting broken PowQL.
+            if (args.distinctOn) {
+                throw new errors_js_1.UnsupportedFeatureError('groupBy distinctOn row source', 'PowDB');
+            }
+            for (const entry of args.by) {
+                if (typeof entry !== 'string') {
+                    throw new errors_js_1.UnsupportedFeatureError('JSON-path groupBy keys', 'PowDB');
+                }
+            }
+            for (const fn of ['_sum', '_avg', '_min', '_max']) {
+                const spec = args[fn];
+                if (!spec)
+                    continue;
+                for (const value of Object.values(spec)) {
+                    if (value !== undefined && typeof value !== 'boolean') {
+                        throw new errors_js_1.UnsupportedFeatureError(`JSON-path ${fn} aggregate targets`, 'PowDB');
+                    }
+                }
+            }
             const params = [];
             const resolvedWhere = await this.resolveRelationFilters(args.where, args.timeout);
             const where = this.buildWhere(resolvedWhere, params);

package/dist/cjs/query/batched-loader.js

@@ -52,9 +52,11 @@ exports.includeKeysForBatching = includeKeysForBatching;
 exports.stripFields = stripFields;
 exports.neededParentKeyFields = neededParentKeyFields;
 exports.resolveCountRelations = resolveCountRelations;
+exports.rejectNestedPickOrder = rejectNestedPickOrder;
 exports.loadRelationsBatched = loadRelationsBatched;
 const errors_js_1 = require("../errors.js");
 const schema_js_1 = require("../schema.js");
+const filters_js_1 = require("./filters.js");
 /**
  * Max parent keys per follow-up query. On Postgres the whole key set travels as
  * ONE array parameter (`= ANY($1)`), so this is not a bind-parameter limit — it
@@ -184,6 +186,34 @@ function resolveCountRelations(parentMeta, countSpec) {
 function keyOf(value) {
     return String(value);
 }
+/**
+ * Reject pick-row relation ordering anywhere inside a `with` tree's orderBy —
+ * strategy parity with the join path, which throws this exact E003 at SQL
+ * build time (`pickOrderNestedError` in builder.ts). Without this guard the
+ * loaders would forward `options.orderBy` as the child reader's TOP-LEVEL
+ * findMany orderBy, where the pick shape compiles fine — so the same query
+ * would execute on 'batched' but throw on 'join'. Walks the whole tree up
+ * front so acceptance never depends on which levels have rows — the batched
+ * runners in builder.ts call this BEFORE the base query (a zero-row base
+ * result must still reject, exactly like the join strategy's build-time throw).
+ */
+function rejectNestedPickOrder(withClause) {
+    for (const spec of Object.values(withClause)) {
+        if (!spec || spec === true)
+            continue;
+        const options = spec;
+        if (options.orderBy) {
+            for (const [key, value] of Object.entries(options.orderBy)) {
+                if ((0, filters_js_1.isRelationPickOrderBy)(value)) {
+                    throw new errors_js_1.ValidationError(`[turbine] Pick-row ordering on relation "${key}" is only supported in a top-level ` +
+                        'findMany orderBy: nested `with` orderBy does not support it.');
+                }
+            }
+        }
+        if (options.with)
+            rejectNestedPickOrder(options.with);
+    }
+}
 /**
  * Load every relation in `withClause` for `parents` and attach it onto each row
  * in place. Mirrors the join strategy's output shape exactly. Recurses for nested
@@ -192,6 +222,10 @@ function keyOf(value) {
 async function loadRelationsBatched(ctx, parents, withClause, timeout, depth = 0, path = [ctx.parentMeta.name]) {
     if (depth >= MAX_DEPTH)
         throw new errors_js_1.CircularRelationError([...path, '…']);
+    // Scope-rule parity with the join strategy: validate the whole tree BEFORE
+    // the empty-parents early return, so accept/reject never depends on data.
+    if (depth === 0)
+        rejectNestedPickOrder(withClause);
     if (parents.length === 0)
         return;
     // Sibling relations are independent (each writes only its own parent[relName]