turbine-orm 0.76.0 → 0.77.0

package/dist/query/relations.js

@@ -112,8 +112,7 @@ export function resolveProjection(qi, table, meta, select, omit, includePii) {
         // 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.`);
+            throw new ValidationError(`"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. An explicit `select` naming a
         // PII column IS the opt-in: it comes back regardless of `includePii`.
@@ -155,7 +154,7 @@ export function resolveProjection(qi, table, meta, select, omit, includePii) {
     const hasPii = piiCols !== undefined && piiCols.size > 0;
     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.`);
+            throw new ValidationError(`"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 (and PII columns).
         const omitCols = new Set(Object.entries(omit)
@@ -506,7 +505,7 @@ export function buildOrderBy(qi, orderBy, params, lateralSink) {
             if (meta)
                 resolveOrderByColumn(qi, qi.table, meta, key);
             if (!params) {
-                throw new ValidationError(`[turbine] Vector distance ordering on "${key}" is only supported in a top-level findMany orderBy.`);
+                throw new ValidationError(`Vector distance ordering on "${key}" is only supported in a top-level findMany orderBy.`);
             }
             const rawColumn = qi.toColumn(key);
             const operator = whereMod.vectorOperator(qi, key, rawColumn, value.distance.metric);
@@ -586,7 +585,7 @@ export function nullsSuffix(qi, nulls) {
 export function resolveOrderByColumn(_qi, table, meta, key) {
     const col = resolveColumnName(meta, key);
     if (col === undefined) {
-        throw new ValidationError(`[turbine] Unknown field "${key}" in orderBy on table "${table}". ` +
+        throw new ValidationError(`Unknown field "${key}" in orderBy on table "${table}". ` +
             `Known fields: ${Object.keys(meta.columnMap).join(', ') || '(none)'}.`);
     }
     return col;
@@ -602,12 +601,12 @@ export function validateJsonPathOrderBy(qi, table, meta, field, spec) {
     const col = resolveOrderByColumn(qi, table, meta, field);
     if (spec.path.length === 0 ||
         spec.path.some((el) => typeof el !== 'string' && !(typeof el === 'number' && Number.isFinite(el)))) {
-        throw new ValidationError(`[turbine] JSON-path orderBy on "${field}" (table "${table}") requires a non-empty \`path\` array ` +
+        throw new ValidationError(`JSON-path orderBy on "${field}" (table "${table}") requires a non-empty \`path\` array ` +
             `of keys/indexes (e.g. { path: ['weight'], direction: 'asc' }).`);
     }
     const colType = whereMod.pgTypeForColumn(qi, meta, col);
     if (!whereMod.isJsonColumnType(qi, colType)) {
-        throw new ValidationError(`[turbine] JSON-path orderBy on "${field}": column "${col}" on table "${table}" is not a JSON column ` +
+        throw new ValidationError(`JSON-path orderBy on "${field}": column "${col}" on table "${table}" is not a JSON column ` +
             `(actual type: ${colType}).`);
     }
     return col;
@@ -624,7 +623,7 @@ export function validateJsonPathOrderBy(qi, table, meta, field, spec) {
 export function buildJsonPathOrderEntry(qi, table, meta, field, spec, prefix, params) {
     const col = validateJsonPathOrderBy(qi, table, meta, field, spec);
     if (!params) {
-        throw new ValidationError(`[turbine] JSON-path ordering on "${field}" is not supported in this orderBy context.`);
+        throw new ValidationError(`JSON-path ordering on "${field}" is not supported in this orderBy context.`);
     }
     params.push(whereMod.jsonPathParam(qi, spec.path));
     const extract = qi.dialect.buildJsonPathExtract(`${prefix}${qi.q(col)}`, qi.p(params.length));
@@ -676,14 +675,14 @@ function buildChainedToOneOrderBy(qi, head, nextRelName, nextValue, params) {
     // relation object. Bounded by the same depth cap as nested `with`.
     for (;;) {
         if (!currentMeta)
-            throw new RelationError(`[turbine] Unknown relation target in orderBy chain "${path.join('.')}"`);
+            throw new RelationError(`Unknown relation target in orderBy chain "${path.join('.')}"`);
         const relDef = ownLookup(currentMeta.relations, relName);
         if (!relDef) {
-            throw new ValidationError(`[turbine] Unknown relation "${relName}" in orderBy on relation "${path.join('.')}" ` +
+            throw new ValidationError(`Unknown relation "${relName}" in orderBy on relation "${path.join('.')}" ` +
                 `(table "${currentMeta.name}"). Available: ${Object.keys(currentMeta.relations).join(', ') || '(none)'}.`);
         }
         if (relDef.type !== 'belongsTo' && relDef.type !== 'hasOne') {
-            throw new ValidationError(`[turbine] orderBy cannot traverse the to-many relation "${relName}" on "${currentMeta.name}" ` +
+            throw new ValidationError(`orderBy cannot traverse the to-many relation "${relName}" on "${currentMeta.name}" ` +
                 `(path "${path.concat(relName).join('.')}"): a to-many relation has no single value to order by. ` +
                 `Use a pick-row ordering ({ pick, by }) at the top level, or order by "_count".`);
         }
@@ -692,7 +691,7 @@ function buildChainedToOneOrderBy(qi, head, nextRelName, nextValue, params) {
         }
         const nextMeta = qi.schema.tables[relDef.to];
         if (!nextMeta)
-            throw new RelationError(`[turbine] Unknown relation target "${relDef.to}" in orderBy`);
+            throw new RelationError(`Unknown relation target "${relDef.to}" in orderBy`);
         const nextAlias = `${head.alias}c${hop}`;
         const on = relDef.type === 'belongsTo'
             ? qi.dialect.buildCorrelation(nextAlias, relDef.referenceKey, currentAlias, relDef.foreignKey)
@@ -710,7 +709,7 @@ function buildChainedToOneOrderBy(qi, head, nextRelName, nextValue, params) {
         // Exactly one key per level, as with the single-hop form.
         const entries = Object.entries(value);
         if (entries.length !== 1) {
-            throw new ValidationError(`[turbine] orderBy on relation "${path.join('.')}" needs exactly one key per level ` +
+            throw new ValidationError(`orderBy on relation "${path.join('.')}" needs exactly one key per level ` +
                 `(got: ${entries.map(([k]) => k).join(', ') || '(empty)'}).`);
         }
         const [key, entryValue] = entries[0];
@@ -726,7 +725,7 @@ function buildChainedToOneOrderBy(qi, head, nextRelName, nextValue, params) {
         // Terminal: a column on the last table in the chain.
         const snakeCol = resolveColumnName(currentMeta, key);
         if (snakeCol === undefined) {
-            throw new ValidationError(`[turbine] Unknown column "${key}" in orderBy on relation "${path.join('.')}" (table "${currentMeta.name}").`);
+            throw new ValidationError(`Unknown column "${key}" in orderBy on relation "${path.join('.')}" (table "${currentMeta.name}").`);
         }
         assertOrderDirection(entryValue, `orderBy on relation path "${path.join('.')}"`);
         const { dir, nulls } = normalizeOrderBy(entryValue);
@@ -774,9 +773,9 @@ export function buildRelationOrderBy(qi, relName, value, alias, params, ctx, lat
         // missing relation.
         const isColumn = resolveColumnName(ownerMeta, relName) !== undefined;
         throw new RelationError(isColumn
-            ? `[turbine] orderBy on "${ownerTable}.${relName}" got a relation-shaped value, but "${relName}" is a ` +
+            ? `orderBy on "${ownerTable}.${relName}" got a relation-shaped value, but "${relName}" is a ` +
                 `column. Order a column with 'asc' / 'desc' (or { sort, nulls }); the object form is for relations.`
-            : `[turbine] Unknown relation "${relName}" in orderBy on table "${ownerTable}". ` +
+            : `Unknown relation "${relName}" in orderBy on table "${ownerTable}". ` +
                 availableClause(Object.keys(ownerMeta.relations), `"${ownerTable}" has no relations.`));
     }
     // Pick-row ordering (`{ pick, by }`): order by a value from ONE related
@@ -792,7 +791,7 @@ export function buildRelationOrderBy(qi, relName, value, alias, params, ctx, lat
     if (relDef.type === 'hasMany' || relDef.type === 'manyToMany') {
         const keys = Object.keys(value);
         if (keys.length !== 1 || keys[0] !== '_count') {
-            throw new ValidationError(`[turbine] orderBy on to-many relation "${relName}" only supports "_count" ` +
+            throw new ValidationError(`orderBy on to-many relation "${relName}" only supports "_count" ` +
                 `or a pick-row ordering ({ pick, by }) (got: ${keys.join(', ') || '(empty)'}).`);
         }
         assertOrderDirection(value._count, `orderBy { ${relName}: { _count } }`);
@@ -802,7 +801,7 @@ export function buildRelationOrderBy(qi, relName, value, alias, params, ctx, lat
     // To-one: each entry orders by a correlated scalar subquery on a target column.
     const targetMeta = qi.schema.tables[relDef.to];
     if (!targetMeta)
-        throw new RelationError(`[turbine] Unknown relation target "${relDef.to}"`);
+        throw new RelationError(`Unknown relation target "${relDef.to}"`);
     const qTarget = qi.q(relDef.to);
     const qParent = qi.q(parentRef);
     // belongsTo: alias.referenceKey = parent.foreignKey; hasOne: reversed.
@@ -811,7 +810,7 @@ export function buildRelationOrderBy(qi, relName, value, alias, params, ctx, lat
         : qi.dialect.buildCorrelation(alias, relDef.foreignKey, qParent, relDef.referenceKey);
     const entries = Object.entries(value);
     if (entries.length === 0) {
-        throw new ValidationError(`[turbine] orderBy on to-one relation "${relName}" needs at least one target column.`);
+        throw new ValidationError(`orderBy on to-one relation "${relName}" needs at least one target column.`);
     }
     return entries
         .map(([col, dirValue]) => {
@@ -831,7 +830,7 @@ export function buildRelationOrderBy(qi, relName, value, alias, params, ctx, lat
                 ? ` "${col}" is a relation on "${relDef.to}": order by one of ITS columns, e.g. ` +
                     `{ ${relName}: { ${col}: { <column>: 'asc' } } }.`
                 : '';
-            throw new ValidationError(`[turbine] Unknown column "${col}" in orderBy on relation "${relName}" (table "${relDef.to}").${relationHint}`);
+            throw new ValidationError(`Unknown column "${col}" in orderBy on relation "${relName}" (table "${relDef.to}").${relationHint}`);
         }
         assertOrderDirection(dirValue, `orderBy "${col}" on relation "${relName}"`);
         const { dir, nulls } = normalizeOrderBy(dirValue);
@@ -862,7 +861,7 @@ export function buildRelationOrderBy(qi, relName, value, alias, params, ctx, lat
  *  - `by` must be a target column name or a `{ field, path }` JSON-path spec.
  */
 export function pickOrderNestedError(_qi, relName) {
-    return new ValidationError(`[turbine] Pick-row ordering on relation "${relName}" is only supported in a top-level ` +
+    return new ValidationError(`Pick-row ordering on relation "${relName}" is only supported in a top-level ` +
         'findMany orderBy: nested `with` orderBy does not support it.');
 }
 export function validatePickOrderBy(qi, relName, relDef, spec, nested) {
@@ -870,10 +869,10 @@ export function validatePickOrderBy(qi, relName, relDef, spec, nested) {
         throw pickOrderNestedError(qi, relName);
     }
     if (relDef.type === 'manyToMany') {
-        throw new ValidationError(`[turbine] Pick-row ordering is not supported on manyToMany relation "${relName}": hasMany relations only.`);
+        throw new ValidationError(`Pick-row ordering is not supported on manyToMany relation "${relName}": hasMany relations only.`);
     }
     if (relDef.type !== 'hasMany') {
-        throw new ValidationError(`[turbine] Pick-row ordering is only for to-many (hasMany) relations; "${relName}" is ${relDef.type}. ` +
+        throw new ValidationError(`Pick-row ordering is only for to-many (hasMany) relations; "${relName}" is ${relDef.type}. ` +
             `Order by the target column directly instead ({ ${relName}: { <column>: 'asc' } }).`);
     }
     const pickOrder = spec.pick?.orderBy;
@@ -882,20 +881,20 @@ export function validatePickOrderBy(qi, relName, relDef, spec, nested) {
         typeof pickOrder !== 'object' ||
         pickOrder === null ||
         Object.keys(pickOrder).length === 0) {
-        throw new ValidationError(`[turbine] Pick-row ordering on relation "${relName}" requires \`pick.orderBy\` to choose ONE ` +
+        throw new ValidationError(`Pick-row ordering on relation "${relName}" requires \`pick.orderBy\` to choose ONE ` +
             "related row deterministically (e.g. pick: { orderBy: { createdAt: 'desc' } }).");
     }
     const by = spec.by;
     const validJsonBy = typeof by === 'object' && by !== null && typeof by.field === 'string' && Array.isArray(by.path);
     if (typeof by !== 'string' && !validJsonBy) {
-        throw new ValidationError(`[turbine] Pick-row ordering on relation "${relName}" requires \`by\`: a target column name ` +
+        throw new ValidationError(`Pick-row ordering on relation "${relName}" requires \`by\`: a target column name ` +
             "or a JSON-path spec ({ field: 'data', path: ['title'] }).");
     }
     // Physical plan gate. A typo like `plan: 'latreal'` must never silently run
     // the subquery plan (a silent plan change wearing a validation gap). Shared
     // by build and cache-hit collect so a warmed cache throws identically.
     if (spec.plan !== undefined && spec.plan !== 'subquery' && spec.plan !== 'lateral') {
-        throw new ValidationError(`[turbine] Pick-row ordering on relation "${relName}" has an invalid \`plan\`: ` +
+        throw new ValidationError(`Pick-row ordering on relation "${relName}" has an invalid \`plan\`: ` +
             `${JSON.stringify(spec.plan)}. Use 'subquery' (default) or 'lateral'.`);
     }
     if (spec.plan === 'lateral') {
@@ -906,7 +905,7 @@ export function validatePickOrderBy(qi, relName, relDef, spec, nested) {
         // parent column with that exact name would make the unqualified WHERE
         // reference ambiguous once the join is in scope; refuse it explicitly.
         if (qi.tableMeta.allColumns.includes('__turbine_pick')) {
-            throw new ValidationError(`[turbine] Pick-row ordering with plan: 'lateral' cannot be used: table "${qi.tableMeta.name}" ` +
+            throw new ValidationError(`Pick-row ordering with plan: 'lateral' cannot be used: table "${qi.tableMeta.name}" ` +
                 'has a column named "__turbine_pick", which the lateral join output reserves.');
         }
     }
@@ -930,11 +929,11 @@ export function validatePickOrderBy(qi, relName, relDef, spec, nested) {
  */
 export function buildRelationPickOrderBy(qi, relName, relDef, spec, alias, parentRef, params, lateralSink) {
     if (!params) {
-        throw new ValidationError(`[turbine] Pick-row ordering on relation "${relName}" is only supported in a top-level findMany orderBy.`);
+        throw new ValidationError(`Pick-row ordering on relation "${relName}" is only supported in a top-level findMany orderBy.`);
     }
     const targetMeta = qi.schema.tables[relDef.to];
     if (!targetMeta)
-        throw new RelationError(`[turbine] Unknown relation target "${relDef.to}"`);
+        throw new RelationError(`Unknown relation target "${relDef.to}"`);
     assertDirectionToken(spec.direction, `pick-row orderBy on relation "${relName}"`);
     const dir = spec.direction?.toLowerCase() === 'desc' ? 'DESC' : 'ASC';
     const limitOne = qi.buildPagination('1', undefined, true);
@@ -959,7 +958,7 @@ export function buildRelationPickOrderBy(qi, relName, relDef, spec, alias, paren
     // context and hard-fails rather than silently emitting a subquery.
     if (spec.plan === 'lateral') {
         if (!lateralSink) {
-            throw new ValidationError(`[turbine] Pick-row ordering with plan: 'lateral' on relation "${relName}" is only supported ` +
+            throw new ValidationError(`Pick-row ordering with plan: 'lateral' on relation "${relName}" is only supported ` +
                 'in a top-level findMany orderBy.');
         }
         const childAlias = `${alias}i`;
@@ -1026,7 +1025,7 @@ export function collectRelationPickOrderParams(qi, relName, relDef, spec, params
     validatePickOrderBy(qi, relName, relDef, spec, false);
     const targetMeta = qi.schema.tables[relDef.to];
     if (!targetMeta)
-        throw new RelationError(`[turbine] Unknown relation target "${relDef.to}"`);
+        throw new RelationError(`Unknown relation target "${relDef.to}"`);
     if (typeof spec.by === 'string') {
         resolveOrderByColumn(qi, relDef.to, targetMeta, spec.by);
     }
@@ -1071,7 +1070,7 @@ export function buildRelationOrderClause(qi, targetTable, targetMeta, alias, ord
     const orders = orderEntries
         .map(([key, dirValue]) => {
         if (isVectorOrderBy(dirValue)) {
-            throw new ValidationError(`[turbine] Vector distance ordering on "${key}" is only supported in a top-level findMany orderBy.`);
+            throw new ValidationError(`Vector distance ordering on "${key}" is only supported in a top-level findMany orderBy.`);
         }
         if (isJsonPathOrderBy(dirValue)) {
             return buildJsonPathOrderEntry(qi, targetTable, targetMeta, key, dirValue, `${alias}.`, params);
@@ -1097,7 +1096,7 @@ export function buildRelationOrderClause(qi, targetTable, targetMeta, alias, ord
 export function collectRelationOrderParams(qi, targetTable, targetMeta, orderEntries, params) {
     for (const [key, dirValue] of orderEntries) {
         if (isVectorOrderBy(dirValue)) {
-            throw new ValidationError(`[turbine] Vector distance ordering on "${key}" is only supported in a top-level findMany orderBy.`);
+            throw new ValidationError(`Vector distance ordering on "${key}" is only supported in a top-level findMany orderBy.`);
         }
         if (isJsonPathOrderBy(dirValue)) {
             validateJsonPathOrderBy(qi, targetTable, targetMeta, key, dirValue);
@@ -1141,7 +1140,7 @@ export function buildRelationCountExpr(qi, relDef, parentRef, alias, params) {
     const count = qi.castAgg('COUNT(*)', 'int');
     if (relDef.type === 'manyToMany') {
         if (!relDef.through) {
-            throw new ValidationError(`[turbine] manyToMany relation "${relDef.name}" is missing its \`through\` junction.`);
+            throw new ValidationError(`manyToMany relation "${relDef.name}" is missing its \`through\` junction.`);
         }
         const qJ = qi.q(relDef.through.table);
         const jalias = `${alias}j`;
@@ -1325,9 +1324,22 @@ export function parseNestedRow(qi, row, table, fromJson = false) {
                     parsed[relName] = jsonVal;
                 }
             }
-            catch {
-                console.warn(`[turbine] Warning: Failed to parse JSON for relation "${relName}" on table "${qi.table}". Using raw value.`);
-                parsed[relName] = rawValue;
+            catch (err) {
+                // A relation column that does not parse is a bug in the emitted SQL or
+                // a driver-level corruption, not a recoverable condition. Handing back
+                // the raw string satisfied the assignment and violated the generated
+                // type: callers got a `string` where `Post[]` was promised, and found
+                // out at the first `.map`. Throw instead, with the context needed to
+                // find it.
+                //
+                // The warn is gated and deduped because this sits in parseNestedRow's
+                // per-relation loop: one 10,000-row page was 10,000 console.warn calls.
+                if (process.env.NODE_ENV !== 'production' &&
+                    shouldWarnOnce(WARN_NS.relationParseFailure, `${qi.table}.${relName}`)) {
+                    console.warn(`[turbine] Relation "${relName}" on "${qi.table}" returned a payload that is not valid JSON. ` +
+                        `This is a bug; please report it with the emitted SQL.`);
+                }
+                throw new ValidationError(`Relation "${relName}" on table "${qi.table}" returned a payload that could not be parsed as JSON.`, { cause: err });
             }
         }
         else if (Array.isArray(rawValue)) {
@@ -2158,7 +2170,7 @@ export function makeFlattenParser(qi, plan) {
 export function buildSelectWithRelations(qi, table, withClause, params, columnsList, depth, path, includePii, flatten) {
     const meta = qi.schema.tables[table];
     if (!meta)
-        throw new ValidationError(`[turbine] Unknown table "${table}"`);
+        throw new ValidationError(`Unknown table "${table}"`);
     // Positional JSON encoding is Postgres-only in v1. Gate here, the single
     // entry point for every `with` clause, so no engine ever emits the
     // json_build_array shape its dialect can't produce (and mssql's FOR JSON
@@ -2177,7 +2189,7 @@ export function buildSelectWithRelations(qi, table, withClause, params, columnsL
             continue;
         const relDef = ownLookup(meta.relations, relName);
         if (!relDef) {
-            throw new RelationError(`[turbine] Unknown relation "${relName}" on table "${table}". ` +
+            throw new RelationError(`Unknown relation "${relName}" on table "${table}". ` +
                 availableClause(Object.keys(meta.relations), `"${table}" has no relations.`));
         }
         // `relationLoadStrategy: 'flatten'`: an eligible to-one relation becomes a
@@ -2311,7 +2323,7 @@ export function buildRelationSubquery(qi, relDef, spec, params, parentRef, alias
     }
     const targetMeta = qi.schema.tables[targetTable];
     if (!targetMeta)
-        throw new RelationError(`[turbine] Unknown relation target "${targetTable}"`);
+        throw new RelationError(`Unknown relation target "${targetTable}"`);
     // `true` IS `{}`; below this line there is no `true` case, which is what
     // keeps this walk and collectRelationSubqueryParams reading one shape.
     // The raw `spec` is still what crosses the dialect seam below, since
@@ -2416,7 +2428,7 @@ export function buildRelationSubquery(qi, relDef, spec, params, parentRef, alias
         for (const [nestedRelName, nestedSpec] of sortedEntries(opts.with)) {
             const nestedRelDef = ownLookup(targetMeta.relations, nestedRelName);
             if (!nestedRelDef) {
-                throw new RelationError(`[turbine] Unknown relation "${nestedRelName}" on table "${targetTable}". ` +
+                throw new RelationError(`Unknown relation "${nestedRelName}" on table "${targetTable}". ` +
                     availableClause(Object.keys(targetMeta.relations), `"${relDef.to}" has no relations.`));
             }
             // Recursively build nested subquery, passing THIS alias as the parent reference
@@ -2490,7 +2502,7 @@ export function buildRelationSubquery(qi, relDef, spec, params, parentRef, alias
                 for (const [nestedRelName, nestedSpec] of sortedEntries(opts.with)) {
                     const nestedRelDef = ownLookup(targetMeta.relations, nestedRelName);
                     if (!nestedRelDef) {
-                        throw new RelationError(`[turbine] Unknown relation "${nestedRelName}" on table "${targetTable}". ` +
+                        throw new RelationError(`Unknown relation "${nestedRelName}" on table "${targetTable}". ` +
                             availableClause(Object.keys(targetMeta.relations), `"${relDef.to}" has no relations.`));
                     }
                     const nestedSub = buildRelationSubquery(qi, nestedRelDef, nestedSpec, params, innerAlias, aliasCounter, currentDepth + 1, [...currentPath, relDef.name], includePii);
@@ -2534,7 +2546,7 @@ export function buildRelationSubquery(qi, relDef, spec, params, parentRef, alias
  */
 export function buildManyToManySubquery(qi, relDef, spec, params, parentRef, aliasCounter, currentDepth, currentPath, talias, targetMeta, targetColumns, includePii) {
     if (!relDef.through) {
-        throw new ValidationError(`[turbine] manyToMany relation "${relDef.name}" is missing a \`through\` junction descriptor.`);
+        throw new ValidationError(`manyToMany relation "${relDef.name}" is missing a \`through\` junction descriptor.`);
     }
     // `true` IS `{}`; see {@link relationOptions}. Same reading as
     // buildRelationSubquery and collectRelationSubqueryParams' m2m branch.
@@ -2550,12 +2562,12 @@ export function buildManyToManySubquery(qi, relDef, spec, params, parentRef, ali
     // introspected PK means we cannot know what to JOIN on, fail loudly rather than
     // silently guessing `id` and generating a wrong JOIN.
     if (targetMeta.primaryKey.length === 0) {
-        throw new ValidationError(`[turbine] manyToMany relation "${relDef.name}" targets table "${targetTable}" which has no primary key; ` +
+        throw new ValidationError(`manyToMany relation "${relDef.name}" targets table "${targetTable}" which has no primary key; ` +
             `cannot determine the join column. Define a primary key or use an explicit through descriptor.`);
     }
     const targetPk = targetMeta.primaryKey;
     if (targetKeys.length !== targetPk.length) {
-        throw new ValidationError(`[turbine] manyToMany relation "${relDef.name}": through.targetKey has ${targetKeys.length} column(s) ` +
+        throw new ValidationError(`manyToMany relation "${relDef.name}": through.targetKey has ${targetKeys.length} column(s) ` +
             `but target "${targetTable}" primary key has ${targetPk.length}. Composite keys must pair positionally.`);
     }
     const joinOn = targetKeys.map((jcol, i) => `${jalias}.${qi.q(jcol)} = ${talias}.${qi.q(targetPk[i])}`).join(' AND ');
@@ -2563,7 +2575,7 @@ export function buildManyToManySubquery(qi, relDef, spec, params, parentRef, ali
     const sourceKeys = normalizeKeyColumns(relDef.through.sourceKey);
     const refKeys = normalizeKeyColumns(relDef.referenceKey);
     if (sourceKeys.length !== refKeys.length) {
-        throw new ValidationError(`[turbine] manyToMany relation "${relDef.name}": through.sourceKey has ${sourceKeys.length} column(s) ` +
+        throw new ValidationError(`manyToMany relation "${relDef.name}": through.sourceKey has ${sourceKeys.length} column(s) ` +
             `but referenceKey has ${refKeys.length}. Composite keys must pair positionally.`);
     }
     let whereClause = sourceKeys
@@ -2609,7 +2621,7 @@ export function buildManyToManySubquery(qi, relDef, spec, params, parentRef, ali
             for (const [nestedRelName, nestedSpec] of sortedEntries(opts.with)) {
                 const nestedRelDef = ownLookup(targetMeta.relations, nestedRelName);
                 if (!nestedRelDef) {
-                    throw new RelationError(`[turbine] Unknown relation "${nestedRelName}" on table "${targetTable}". ` +
+                    throw new RelationError(`Unknown relation "${nestedRelName}" on table "${targetTable}". ` +
                         availableClause(Object.keys(targetMeta.relations), `"${relDef.to}" has no relations.`));
                 }
                 const nestedSub = buildRelationSubquery(qi, nestedRelDef, nestedSpec, params, innerAlias, aliasCounter, currentDepth + 1, [...currentPath, relDef.name], includePii);
@@ -2629,7 +2641,7 @@ export function buildManyToManySubquery(qi, relDef, spec, params, parentRef, ali
         for (const [nestedRelName, nestedSpec] of sortedEntries(opts.with)) {
             const nestedRelDef = ownLookup(targetMeta.relations, nestedRelName);
             if (!nestedRelDef) {
-                throw new RelationError(`[turbine] Unknown relation "${nestedRelName}" on table "${targetTable}". ` +
+                throw new RelationError(`Unknown relation "${nestedRelName}" on table "${targetTable}". ` +
                     availableClause(Object.keys(targetMeta.relations), `"${relDef.to}" has no relations.`));
             }
             const nestedSub = buildRelationSubquery(qi, nestedRelDef, nestedSpec, params, talias, aliasCounter, currentDepth + 1, [...currentPath, relDef.name], includePii);

package/dist/query/types.js

@@ -66,7 +66,7 @@ import { ValidationError } from '../errors.js';
 export const UNSAFE = Symbol.for('turbine-orm.UNSAFE');
 /** The one message shape every privilege refusal uses. */
 function privilegeRefusal(option, received, extra = '') {
-    return new ValidationError(`[turbine] \`${option}\` must be the \`UNSAFE\` symbol, received ${describeValue(received)}. ` +
+    return new ValidationError(`\`${option}\` must be the \`UNSAFE\` symbol, received ${describeValue(received)}. ` +
         `${option} is a privilege option: it removes a safety boundary (a tenant filter, the PII ` +
         'projection, or the empty-`where` guard), so it cannot be enabled by a plain value that ' +
         'JSON.parse can produce. Import the sentinel and pass it explicitly: ' +
@@ -138,12 +138,12 @@ export function resolveSkipGlobalFilters(value) {
         // `[UNSAFE, ...tables]` ESCALATE to a global skip whenever `tables` happens
         // to come back empty, which is the same accident with a much worse outcome.
         if (tables.length === 0) {
-            throw new ValidationError('[turbine] `skipGlobalFilters: [UNSAFE]` names no table, so it would skip nothing. ' +
+            throw new ValidationError('`skipGlobalFilters: [UNSAFE]` names no table, so it would skip nothing. ' +
                 'Pass the tables to skip (`[UNSAFE, "posts"]`), or the bare sentinel (`UNSAFE`) to skip every table.');
         }
         for (const t of tables) {
             if (typeof t !== 'string') {
-                throw new ValidationError('[turbine] `skipGlobalFilters: [UNSAFE, ...]` takes table accessor NAMES after the sentinel, ' +
+                throw new ValidationError('`skipGlobalFilters: [UNSAFE, ...]` takes table accessor NAMES after the sentinel, ' +
                     `received ${describeValue(t)}.`);
             }
         }
@@ -205,7 +205,7 @@ export function assertDirectionToken(value, context) {
         if (lowered === 'asc' || lowered === 'desc')
             return;
     }
-    throw new ValidationError(`[turbine] Invalid orderBy direction ${describeValue(value)} for ${context}. ` +
+    throw new ValidationError(`Invalid orderBy direction ${describeValue(value)} for ${context}. ` +
         "Use 'asc' or 'desc'. An unrecognized direction used to sort ASCENDING silently, " +
         'which returns a correct-looking page in the wrong order.');
 }

package/dist/query/utils.js

@@ -1415,7 +1415,7 @@ export function unknownFieldMessage(table, field, meta) {
     const didYouMean = suggestion
         ? ` Did you mean "${suggestion}"${relations.includes(suggestion) ? ' (a relation)' : ''}?`
         : '';
-    return (`[turbine] Unknown field "${field}" on table "${table}".${didYouMean}` +
+    return (`Unknown field "${field}" on table "${table}".${didYouMean}` +
         ` Known columns: ${columns.join(', ') || '(none)'}.` +
         (relations.length ? ` Known relations (valid in \`where\` and \`with\`): ${relations.join(', ')}.` : ''));
 }
@@ -1450,7 +1450,7 @@ export function availableClause(names, emptySentence) {
  * it. Naming the fix costs one sentence and saves a search.
  */
 export function relationInProjectionMessage(table, field, clause) {
-    const head = `[turbine] "${field}" is a relation on table "${table}", not a column, so it cannot be named in \`${clause}\`.`;
+    const head = `"${field}" is a relation on table "${table}", not a column, so it cannot be named in \`${clause}\`.`;
     return clause === 'select'
         ? `${head} Load it with \`with: { ${field}: true }\`, which is a sibling of \`select\`, not a member of it.` +
             " To narrow the relation's own columns, put a `select` inside that relation's options:" +
@@ -1501,11 +1501,11 @@ export function warnRedundantSortTerm(table, clause, dropped) {
  * which is exactly the class 0.64/0.65 exist to kill.
  */
 export function selectNamesNothingMessage(table) {
-    return (`[turbine] "select" names no fields (on table "${table}"): every value is false or it is empty. ` +
+    return (`"select" names no fields (on table "${table}"): every value is false or it is empty. ` +
         `Pass at least one field as true, or drop "select" to get the default projection.`);
 }
 export function selectOmitExclusiveMessage(table) {
-    return (`[turbine] "select" and "omit" are mutually exclusive (on table "${table}"). ` +
+    return (`"select" and "omit" are mutually exclusive (on table "${table}"). ` +
         `A select already lists exactly the fields you want.`);
 }
 /**
@@ -1559,7 +1559,7 @@ export function normalizePagination(args) {
 function assertAliasAgrees(alias, aliasValue, native, nativeValue) {
     if (nativeValue === undefined || nativeValue === aliasValue)
         return;
-    throw new ValidationError(`[turbine] "${alias}" and "${native}" are the same option and were given different values ` +
+    throw new ValidationError(`"${alias}" and "${native}" are the same option and were given different values ` +
         `(${alias}: ${String(aliasValue)}, ${native}: ${String(nativeValue)}). ` +
         `"${alias}" is Prisma's spelling of "${native}"; pass one of them.`);
 }

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

@@ -127,4 +127,11 @@ export declare const WARN_NS: {
      * Keyed on the requested mode.
      */
     readonly planCacheModeIgnored: "planCacheModeIgnored";
+    /**
+     * A relation's JSON payload could not be parsed in `parseNestedRow`
+     * (relations.ts). Keyed on `table.relation`, so a page of 10,000 rows whose
+     * relation column is malformed says it once rather than once per row: the
+     * warn sits in the per-relation loop, which runs once per row per relation.
+     */
+    readonly relationParseFailure: "relationParseFailure";
 };

package/dist/query/warn-registry.js

@@ -162,4 +162,11 @@ export const WARN_NS = {
      * Keyed on the requested mode.
      */
     planCacheModeIgnored: 'planCacheModeIgnored',
+    /**
+     * A relation's JSON payload could not be parsed in `parseNestedRow`
+     * (relations.ts). Keyed on `table.relation`, so a page of 10,000 rows whose
+     * relation column is malformed says it once rather than once per row: the
+     * warn sits in the per-relation loop, which runs once per row per relation.
+     */
+    relationParseFailure: 'relationParseFailure',
 };

package/dist/query/where-compile.js

@@ -68,7 +68,7 @@ export const MAX_WHERE_DEPTH = 32;
 export function assertWhereDepth(depth, clause = 'where') {
     if (depth <= MAX_WHERE_DEPTH)
         return;
-    throw new ValidationError(`[turbine] \`${clause}\` clause nests more than ${MAX_WHERE_DEPTH} levels of AND / OR / NOT ` +
+    throw new ValidationError(`\`${clause}\` clause nests more than ${MAX_WHERE_DEPTH} levels of AND / OR / NOT ` +
         `(or relation filters) deep. That is far past anything a real predicate needs, and an unbounded ` +
         `walk over caller-supplied nesting is a stack-overflow surface, so it is refused. If this is a ` +
         `generated predicate, flatten it: a single \`AND\` / \`OR\` array of N conditions is one level, ` +