turbine-orm 0.76.0 → 0.77.0

package/dist/query/aggregates.js

@@ -37,7 +37,7 @@ export function assertAggregatePiiOptIn(table, meta, field, column, usage, inclu
     const colMeta = meta.columns.find((c) => c.name === column);
     if (!colMeta?.pii)
         return;
-    throw new ValidationError(`[turbine] ${usage} on column "${field}" of table "${table}" is refused: that column is ` +
+    throw new ValidationError(`${usage} on column "${field}" of table "${table}" is refused: that column is ` +
         'PII-tagged (`pii: true`), and this aggregate returns its stored values, which are excluded ' +
         'from every default projection. Pass `includePii: UNSAFE` on this call to opt in ' +
         "(import { UNSAFE } from 'turbine-orm'). " +
@@ -101,7 +101,7 @@ export function buildGroupBy(qi, args) {
     const usedResultKeys = new Set();
     const claimResultKey = (key, what) => {
         if (key === '_count' || usedResultKeys.has(key)) {
-            throw new ValidationError(`[turbine] groupBy output name "${key}" (${what}) collides with another output column on table ` +
+            throw new ValidationError(`groupBy output name "${key}" (${what}) collides with another output column on table ` +
                 `"${qi.table}": set an explicit \`alias\` (or rename the aggregate key) to disambiguate.`);
         }
         usedResultKeys.add(key);
@@ -224,7 +224,7 @@ export function buildGroupBy(qi, args) {
             }
             const alwaysNumeric = aggKey === '_sum' || aggKey === '_avg';
             if (alwaysNumeric && target.type === 'text') {
-                throw new ValidationError(`[turbine] groupBy ${aggKey} target "${key}" on table "${qi.table}": ` +
+                throw new ValidationError(`groupBy ${aggKey} target "${key}" on table "${qi.table}": ` +
                     `${aggKey} over a JSON path is always numeric: remove \`type: 'text'\`.`);
             }
             const numeric = alwaysNumeric || target.type === 'numeric';
@@ -446,7 +446,7 @@ export function buildGroupByOrderBy(qi, orderBy, byOrderExprs, aggOrderExprs) {
             if (key === '_count') {
                 const expr = aggOrderExprs.get('_count');
                 if (!expr) {
-                    throw new ValidationError(`[turbine] Cannot order groupBy by "_count" on table "${qi.table}": _count is not selected. ` +
+                    throw new ValidationError(`Cannot order groupBy by "_count" on table "${qi.table}": _count is not selected. ` +
                         `Orderable keys: ${validKeys()}.`);
                 }
                 // Refuse a direction that is neither asc nor desc BEFORE normalizeOrderBy,
@@ -457,7 +457,7 @@ export function buildGroupByOrderBy(qi, orderBy, byOrderExprs, aggOrderExprs) {
             }
             // `_sum` / `_avg` / `_min` / `_max`: an object of field → direction/spec.
             if (typeof value !== 'object' || value === null || Array.isArray(value)) {
-                throw new ValidationError(`[turbine] Invalid groupBy orderBy for "${key}" on table "${qi.table}": ` +
+                throw new ValidationError(`Invalid groupBy orderBy for "${key}" on table "${qi.table}": ` +
                     `expected a field map like { ${key}: { amount: 'desc' } }.`);
             }
             for (const [field, dirSpec] of Object.entries(value)) {
@@ -469,7 +469,7 @@ export function buildGroupByOrderBy(qi, orderBy, byOrderExprs, aggOrderExprs) {
                 const expr = aggOrderExprs.get(`${key}:${field}`) ??
                     (canonical === undefined ? undefined : aggOrderExprs.get(`${key}:${canonical}`));
                 if (!expr) {
-                    throw new ValidationError(`[turbine] Cannot order groupBy by "${key}.${field}" on table "${qi.table}": ` +
+                    throw new ValidationError(`Cannot order groupBy by "${key}.${field}" on table "${qi.table}": ` +
                         `that aggregate is not requested in this call. Orderable keys: ${validKeys()}.`);
                 }
                 assertOrderDirection(dirSpec, `groupBy orderBy "${key}.${field}" on table "${qi.table}"`);
@@ -480,8 +480,7 @@ export function buildGroupByOrderBy(qi, orderBy, byOrderExprs, aggOrderExprs) {
         // Plain by-field name or JSON group-key alias.
         const expr = lookupGroupKey(qi, byOrderExprs, key);
         if (!expr) {
-            throw new ValidationError(`[turbine] Unknown field "${key}" in groupBy orderBy on table "${qi.table}". ` +
-                `Orderable keys: ${validKeys()}.`);
+            throw new ValidationError(`Unknown field "${key}" in groupBy orderBy on table "${qi.table}". ` + `Orderable keys: ${validKeys()}.`);
         }
         assertOrderDirection(value, `groupBy orderBy "${key}" on table "${qi.table}"`);
         pushOrderTerm(expr, key, value);
@@ -495,18 +494,18 @@ export function buildGroupByOrderBy(qi, orderBy, byOrderExprs, aggOrderExprs) {
  */
 export function resolveJsonPathTarget(qi, context, field, path) {
     if (typeof field !== 'string') {
-        throw new ValidationError(`[turbine] groupBy ${context} on table "${qi.table}" requires a string \`field\`.`);
+        throw new ValidationError(`groupBy ${context} on table "${qi.table}" requires a string \`field\`.`);
     }
     const col = qi.toColumn(field);
     if (!Array.isArray(path) ||
         path.length === 0 ||
         path.some((el) => typeof el !== 'string' && !(typeof el === 'number' && Number.isFinite(el)))) {
-        throw new ValidationError(`[turbine] groupBy ${context} on "${field}" (table "${qi.table}") requires a non-empty \`path\` ` +
+        throw new ValidationError(`groupBy ${context} on "${field}" (table "${qi.table}") requires a non-empty \`path\` ` +
             `array of keys/indexes (e.g. { field: '${field}', path: ['category'] }).`);
     }
     const colType = whereMod.pgTypeForColumn(qi, qi.tableMeta, col);
     if (!whereMod.isJsonColumnType(qi, colType)) {
-        throw new ValidationError(`[turbine] groupBy ${context} on "${field}": column "${col}" on table "${qi.table}" is not a JSON ` +
+        throw new ValidationError(`groupBy ${context} on "${field}": column "${col}" on table "${qi.table}" is not a JSON ` +
             `column (actual type: ${colType}).`);
     }
     return col;
@@ -530,11 +529,11 @@ export function buildDistinctOnSource(qi, distinctOn, whereSql, params) {
         throw new UnsupportedFeatureError('DISTINCT ON row source (groupBy distinctOn)', qi.dialect.name, 'groupBy({ distinctOn }) requires PostgreSQL: SELECT DISTINCT ON is not portable.');
     }
     if (!Array.isArray(distinctOn.columns) || distinctOn.columns.length === 0) {
-        throw new ValidationError(`[turbine] groupBy distinctOn on table "${qi.table}" requires a non-empty \`columns\` array.`);
+        throw new ValidationError(`groupBy distinctOn on table "${qi.table}" requires a non-empty \`columns\` array.`);
     }
     const orderEntries = Object.entries(distinctOn.orderBy ?? {});
     if (orderEntries.length === 0) {
-        throw new ValidationError(`[turbine] groupBy distinctOn on table "${qi.table}" requires \`orderBy\` to pick ONE row per ` +
+        throw new ValidationError(`groupBy distinctOn on table "${qi.table}" requires \`orderBy\` to pick ONE row per ` +
             "column combination deterministically (e.g. orderBy: { createdAt: 'desc' }).");
     }
     // A repeated DISTINCT ON column is a no-op, so drop it rather than emit it
@@ -554,7 +553,7 @@ export function buildDistinctOnSource(qi, distinctOn, whereSql, params) {
             continue;
         }
         if (isVectorOrderBy(value) || qi.isRelationOrderByValue(value)) {
-            throw new ValidationError(`[turbine] groupBy distinctOn.orderBy on "${key}" (table "${qi.table}") supports plain columns, ` +
+            throw new ValidationError(`groupBy distinctOn.orderBy on "${key}" (table "${qi.table}") supports plain columns, ` +
                 'sort specs, and JSON-path orderings only.');
         }
         const col = qi.resolveOrderByColumn(qi.table, qi.tableMeta, key);
@@ -668,7 +667,7 @@ function splitHavingField(qi, field, value) {
             aggEntries.push({ key: k, fn, filter: v });
         }
         else if (k.startsWith('_')) {
-            throw new ValidationError(`[turbine] Unknown aggregate "${k}" in having for field "${field}" on table "${qi.table}". ` +
+            throw new ValidationError(`Unknown aggregate "${k}" in having for field "${field}" on table "${qi.table}". ` +
                 `Supported: ${Object.keys(HAVING_AGGREGATE_FNS).join(', ')}.`);
         }
         else {
@@ -704,7 +703,7 @@ function buildHavingCombinator(qi, key, value, params, jsonAggExprs, groupKeys,
     const parts = [];
     for (const condition of conditions) {
         if (!isUnmatchedPlainObject(condition)) {
-            throw new ValidationError(`[turbine] Invalid having "${key}" on table "${qi.table}": expected ` +
+            throw new ValidationError(`Invalid having "${key}" on table "${qi.table}": expected ` +
                 `${key === 'OR' ? 'an array of having objects' : 'a having object (or an array of them)'}.`);
         }
         const sub = buildHavingClauses(qi, condition, params, jsonAggExprs, groupKeys, depth + 1);
@@ -745,7 +744,7 @@ function buildHavingScalarClauses(qi, field, value, params, groupKeys) {
     const ref = groupKeys ? lookupGroupKey(qi, groupKeys, field) : undefined;
     if (!ref) {
         const known = groupKeys ? [...groupKeys.keys()] : [];
-        throw new ValidationError(`[turbine] having on "${field}" (table "${qi.table}") filters the grouped value itself, but ` +
+        throw new ValidationError(`having on "${field}" (table "${qi.table}") filters the grouped value itself, but ` +
             `"${field}" is not one of the \`by\` group keys [${known.join(', ') || 'none'}]. A predicate on a ` +
             'non-grouped column cannot go in HAVING: move it to `where` (it filters rows, not groups), add ' +
             `"${field}" to \`by\`, or filter an aggregate of it instead (e.g. { ${field}: { _count: { gt: 0 } } }).`);
@@ -765,7 +764,7 @@ function buildHavingScalarClauses(qi, field, value, params, groupKeys) {
         clauses.push(...whereMod.buildOperatorClauses(qi, ref.expr, value, params));
     }
     else if (isUnmatchedPlainObject(value)) {
-        throw new ValidationError(`[turbine] Unknown operator${Object.keys(value).length > 1 ? 's' : ''} ` +
+        throw new ValidationError(`Unknown operator${Object.keys(value).length > 1 ? 's' : ''} ` +
             `${Object.keys(value)
                 .map((k) => `"${k}"`)
                 .join(', ')} on ${ref.label} in having for table "${qi.table}".`);
@@ -785,7 +784,7 @@ function buildHavingScalarClauses(qi, field, value, params, groupKeys) {
  */
 export function buildHavingNumericClauses(qi, expr, filter, params) {
     if (filter === null) {
-        throw new ValidationError(`[turbine] Invalid having filter on "${expr}" for table "${qi.table}": expected a value or operator object.`);
+        throw new ValidationError(`Invalid having filter on "${expr}" for table "${qi.table}": expected a value or operator object.`);
     }
     // Bare value (number, string, boolean, Date, …) → equality.
     if (typeof filter !== 'object' || filter instanceof Date) {
@@ -796,7 +795,7 @@ export function buildHavingNumericClauses(qi, expr, filter, params) {
     const allowedKeys = new Set(['equals', 'not', 'gt', 'gte', 'lt', 'lte', 'in', 'notIn']);
     for (const k of Object.keys(op)) {
         if (!allowedKeys.has(k)) {
-            throw new ValidationError(`[turbine] Unknown having operator "${k}" on "${expr}" for table "${qi.table}". ` +
+            throw new ValidationError(`Unknown having operator "${k}" on "${expr}" for table "${qi.table}". ` +
                 `Supported: ${[...allowedKeys].join(', ')}.`);
         }
     }

package/dist/query/batched-loader.js

@@ -418,11 +418,11 @@ export function resolveCountRelations(parentMeta, countSpec) {
             continue;
         const rel = ownLookup(parentMeta.relations, relName);
         if (!rel) {
-            throw new RelationError(`[turbine] Unknown relation "${relName}" in _count on table "${parentMeta.name}". ` +
+            throw new RelationError(`Unknown relation "${relName}" in _count on table "${parentMeta.name}". ` +
                 availableClause(Object.keys(parentMeta.relations), 'It has no relations.'));
         }
         if (!isToMany(rel)) {
-            throw new ValidationError(`[turbine] _count is only supported for to-many relations; "${relName}" on ` +
+            throw new ValidationError(`_count is only supported for to-many relations; "${relName}" on ` +
                 `"${parentMeta.name}" is a to-one relation.`);
         }
         out.push(rel);
@@ -452,7 +452,7 @@ export function rejectNestedPickOrder(withClause) {
         if (options.orderBy) {
             for (const [key, value] of Object.entries(options.orderBy)) {
                 if (isRelationPickOrderBy(value)) {
-                    throw new ValidationError(`[turbine] Pick-row ordering on relation "${key}" is only supported in a top-level ` +
+                    throw new ValidationError(`Pick-row ordering on relation "${key}" is only supported in a top-level ` +
                         'findMany orderBy: nested `with` orderBy does not support it.');
                 }
             }
@@ -494,7 +494,7 @@ export async function loadRelationsBatched(ctx, parents, withClause, timeout, de
             // RelationError (E005), NOT ValidationError: the join strategy throws
             // E005 for this exact shape (relations.ts), and under 'auto' the two
             // must refuse identically or the error CODE depends on table size.
-            throw new RelationError(`[turbine] Unknown relation "${relName}" on table "${ctx.parentMeta.name}". ` +
+            throw new RelationError(`Unknown relation "${relName}" on table "${ctx.parentMeta.name}". ` +
                 availableClause(Object.keys(ctx.parentMeta.relations), 'It has no relations.'));
         }
         resolved.push({ relName, rel, options: spec === true ? {} : spec });
@@ -522,7 +522,7 @@ export async function loadRelationsBatched(ctx, parents, withClause, timeout, de
     // nested projections all learning it together, which is a feature release,
     // not a line in a correctness fix. Until then both strategies say no.
     if (hasCount && depth > 0) {
-        throw new RelationError(`[turbine] Unknown relation "_count" on table "${ctx.parentMeta.name}". ` +
+        throw new RelationError(`Unknown relation "_count" on table "${ctx.parentMeta.name}". ` +
             `${availableClause(Object.keys(ctx.parentMeta.relations), 'It has no relations.')} ` +
             '(`_count` is supported on the top-level `with` only, on every relationLoadStrategy.)');
     }
@@ -804,7 +804,7 @@ function stripRankColumn(result) {
 async function loadManyToMany(ctx, parents, rel, relName, options, timeout, depth, path) {
     const through = rel.through;
     if (!through) {
-        throw new ValidationError(`[turbine] manyToMany relation "${relName}" is missing its junction (\`through\`).`);
+        throw new ValidationError(`manyToMany relation "${relName}" is missing its junction (\`through\`).`);
     }
     const sourceJ = normalizeKeyColumns(through.sourceKey);
     const targetJ = normalizeKeyColumns(through.targetKey);
@@ -962,7 +962,7 @@ async function loadOneCount(ctx, parents, rel) {
     if (rel.type === 'manyToMany') {
         const through = rel.through;
         if (!through) {
-            throw new ValidationError(`[turbine] manyToMany relation "${rel.name}" is missing its junction (\`through\`).`);
+            throw new ValidationError(`manyToMany relation "${rel.name}" is missing its junction (\`through\`).`);
         }
         const sourceRef = normalizeKeyColumns(rel.referenceKey);
         const sourceJ = normalizeKeyColumns(through.sourceKey);
@@ -1147,6 +1147,6 @@ function groupBy(rows, field) {
 function requireTable(schema, table, relName) {
     const meta = schema.tables[table];
     if (!meta)
-        throw new RelationError(`[turbine] Unknown relation target "${table}" (relation "${relName}").`);
+        throw new RelationError(`Unknown relation target "${table}" (relation "${relName}").`);
     return meta;
 }

package/dist/query/builder.js

@@ -669,7 +669,7 @@ export class QueryInterface {
         this.schema = schema;
         const meta = schema.tables[table];
         if (!meta) {
-            throw new ValidationError(`[turbine] Unknown table "${table}". ${availableClause(Object.keys(schema.tables), 'The schema has no tables.')}`);
+            throw new ValidationError(`Unknown table "${table}". ${availableClause(Object.keys(schema.tables), 'The schema has no tables.')}`);
         }
         this.tableMeta = meta;
         this.middlewares = middlewares ?? [];
@@ -970,7 +970,7 @@ export class QueryInterface {
     paginationValue(value, arg) {
         const n = Number(value);
         if (!Number.isSafeInteger(n) || n < 0) {
-            throw new ValidationError(`[turbine] ${arg} on "${this.table}" must be a non-negative integer, received: ${String(value)}`);
+            throw new ValidationError(`${arg} on "${this.table}" must be a non-negative integer, received: ${String(value)}`);
         }
         return n;
     }
@@ -1054,7 +1054,7 @@ export class QueryInterface {
             return this.currentJsonEncoding;
         }
         if (!JSON_ENCODINGS.includes(argEncoding)) {
-            throw new ValidationError(`[turbine] Invalid \`jsonEncoding\` on "${this.table}": ${JSON.stringify(argEncoding)}. ` +
+            throw new ValidationError(`Invalid \`jsonEncoding\` on "${this.table}": ${JSON.stringify(argEncoding)}. ` +
                 `Expected ${JSON_ENCODINGS.map((e) => `'${e}'`).join(' or ')}.`);
         }
         this.currentJsonEncoding = argEncoding;
@@ -1882,7 +1882,7 @@ export class QueryInterface {
         if (!paramsOk) {
             details.push(`cache-hit params and freshly-built params diverge (collected ${collectedParams.length}, built ${freshParams.length})`);
         }
-        const message = `[turbine] SQL cache lockstep violation on ${op} (fingerprint "${cacheKey}"). ` +
+        const message = `SQL cache lockstep violation on ${op} (fingerprint "${cacheKey}"). ` +
             `This is a Turbine internal invariant violation, please report it at ` +
             `https://github.com/zvndev/turbine-orm/issues. The fingerprint, SQL-build, and ` +
             `param-collect paths must enumerate where-clause keys identically.\n${details.join('\n')}`;
@@ -1976,7 +1976,7 @@ export class QueryInterface {
                 'engine has no such cache to keep it out of. Remove the option, or set it only on PostgreSQL queries.');
         }
         if (this.options?.planCacheMode === 'force_generic_plan') {
-            throw new ValidationError('[turbine] forceCustomPlan: true cannot be honoured on a client configured with ' +
+            throw new ValidationError('forceCustomPlan: true cannot be honoured on a client configured with ' +
                 "planCacheMode: 'force_generic_plan'. That setting is a connection parameter and it governs UNNAMED " +
                 'statements as well as named ones, so the mechanism this option uses (withholding the ' +
                 'prepared-statement name, so the driver re-parses the statement on every execution and it is planned ' +
@@ -2220,7 +2220,7 @@ export class QueryInterface {
         // optional filter" is its whole contract and Prisma's `findFirst` behaves
         // the same way; ask for one row by identity with `findUnique`.
         if (whereMod.userPredicateIsEmpty(this.ctx, (args.where ?? {}))) {
-            throw new ValidationError(`[turbine] findUnique on "${this.table}" refused: the \`where\` clause has no predicate, ` +
+            throw new ValidationError(`findUnique on "${this.table}" refused: the \`where\` clause has no predicate, ` +
                 'so this would return an arbitrary row rather than a specific one. ' +
                 'A key whose value is `undefined` does not count, check that the value you are looking up is defined. ' +
                 'If you meant "any row matching an optional filter", use `findFirst`.');
@@ -2661,7 +2661,7 @@ export class QueryInterface {
         if (args?.distinct && args.distinct.length > 0 && args.orderBy) {
             for (const [, d] of orderByEntries(args.orderBy)) {
                 if (this.isRelationOrderByValue(d)) {
-                    throw new ValidationError('[turbine] `distinct` cannot be combined with relation orderBy (pick-row, `_count`, or ' +
+                    throw new ValidationError('`distinct` cannot be combined with relation orderBy (pick-row, `_count`, or ' +
                         'to-one relation ordering): the outer re-order cannot reference the parent table.');
                 }
             }
@@ -2858,7 +2858,7 @@ export class QueryInterface {
                 // the user's order (picks the right representative row), outer re-ordered
                 // by the user's order alone.
                 if (orderByEntries(args.orderBy).some(([, d]) => isVectorOrderBy(d))) {
-                    throw new ValidationError('[turbine] `distinct` cannot be combined with vector distance ordering.');
+                    throw new ValidationError('`distinct` cannot be combined with vector distance ordering.');
                 }
                 const userOrder = this.buildOrderBy(args.orderBy, freshParams);
                 const inner = `SELECT ${distinctPrefix}${selectClause} FROM ${qt}${tail} ORDER BY ${distinctCols

package/dist/query/compound-unique.js

@@ -179,7 +179,7 @@ export function expandCompoundUniqueWhere(meta, where) {
             providedByColumn.size === expected.size &&
             [...providedByColumn.keys()].every((c) => expected.has(c));
         if (!exact) {
-            throw new ValidationError(`[turbine] Compound unique selector "${key}" on table "${meta.name}" must supply exactly ` +
+            throw new ValidationError(`Compound unique selector "${key}" on table "${meta.name}" must supply exactly ` +
                 `{ ${fields.join(', ')} }, received { ${provided.join(', ') || '(none)'} }.`);
         }
         result ??= { ...where };
@@ -236,7 +236,7 @@ export function assertWhereIdentifiesOneRow(meta, table, where) {
         ? `Name a unique key (${keys.join(', ')}), or use \`findFirst\` if you meant "any row matching a filter".`
         : `Table "${table}" declares no primary key and no unique constraint, so no \`where\` can identify one row ` +
             'here. Use `findFirst` (add an `orderBy` to make which row it is deterministic).';
-    throw new ValidationError(`[turbine] findUnique on "${table}" refused: the \`where\` clause does not identify a single row, ` +
+    throw new ValidationError(`findUnique on "${table}" refused: the \`where\` clause does not identify a single row, ` +
         `so this would return an arbitrary one of the rows that match. ${advice}`);
 }
 export function uniqueKeyNames(meta) {

package/dist/query/filters.js

@@ -136,7 +136,7 @@ export function fingerprintOperatorShape(value) {
 export function assertBindableEqualsOperand(value, column) {
     if (!isUnmatchedPlainObject(value))
         return;
-    throw new ValidationError(`[turbine] Plain-object value for operator 'equals' on ${column}: ` +
+    throw new ValidationError(`Plain-object value for operator 'equals' on ${column}: ` +
         `objects are only valid 'equals' values on JSON (json/jsonb) columns, ` +
         `where 'equals' is the JSONB containment filter.`);
 }