turbine-orm 0.76.0 → 0.77.0

package/dist/cjs/prisma-compat.js

@@ -361,7 +361,7 @@ function assertTranslateDepth(depth, clause) {
     // The two clauses core also walks raise core's own error, verbatim.
     if (clause === 'where' || clause === 'having')
         (0, where_compile_js_1.assertWhereDepth)(depth, clause);
-    throw new errors_js_1.ValidationError(`[turbine] \`${clause}\` nests more than ${where_compile_js_1.MAX_WHERE_DEPTH} levels deep. That is far past anything a real ` +
+    throw new errors_js_1.ValidationError(`\`${clause}\` nests more than ${where_compile_js_1.MAX_WHERE_DEPTH} levels deep. That is far past anything a real ` +
         `query needs, and an unbounded walk over caller-supplied nesting is a stack-overflow surface, so it is ` +
         `refused. If this is a generated argument, flatten it: a single array of N entries is one level, not N.`);
 }
@@ -752,7 +752,7 @@ function translateOmit(ctx, mm, omit) {
         if (val === false || val == null)
             continue;
         if (mm.relations[key]) {
-            throw new errors_js_1.ValidationError(`[turbine] prisma-compat: \`omit\` on model "${modelName(ctx, mm)}" takes scalar fields, but "${key}" ` +
+            throw new errors_js_1.ValidationError(`prisma-compat: \`omit\` on model "${modelName(ctx, mm)}" takes scalar fields, but "${key}" ` +
                 'is a relation. Leave the relation out of `include` instead.');
         }
         out[renameField(mm, key)] = true;
@@ -778,10 +778,10 @@ function translateProjection(ctx, mm, args, depth = 0) {
     const select = args.select;
     const omitArg = args.omit;
     if (include && select) {
-        throw new errors_js_1.ValidationError('[turbine] prisma-compat: `include` and `select` are mutually exclusive.');
+        throw new errors_js_1.ValidationError('prisma-compat: `include` and `select` are mutually exclusive.');
     }
     if (select && omitArg) {
-        throw new errors_js_1.ValidationError('[turbine] prisma-compat: `select` and `omit` are mutually exclusive. ' +
+        throw new errors_js_1.ValidationError('prisma-compat: `select` and `omit` are mutually exclusive. ' +
             'A `select` already lists exactly the fields you want.');
     }
     const omit = omitArg ? translateOmit(ctx, mm, omitArg) : undefined;
@@ -798,7 +798,7 @@ function translateProjection(ctx, mm, args, depth = 0) {
             }
             const rel = mm.relations[key];
             if (!rel) {
-                throw new errors_js_1.ValidationError(`[turbine] prisma-compat: unknown relation "${key}" in include on model "${modelName(ctx, mm)}".`);
+                throw new errors_js_1.ValidationError(`prisma-compat: unknown relation "${key}" in include on model "${modelName(ctx, mm)}".`);
             }
             withClause[rel.name] = translateWithOption(ctx, mm, rel.name, val, depth + 1);
             hasWith = true;
@@ -853,7 +853,7 @@ function assertWriteProjectionField(ctx, mm, op, clause, key) {
         return;
     const known = Object.keys(mm.fields);
     const suggestion = (0, utils_js_1.suggestKey)(key, new Set(known));
-    throw new errors_js_1.ValidationError(`[turbine] prisma-compat: unknown field "${key}" in \`${clause}\` on ${modelName(ctx, mm)}.${op}().` +
+    throw new errors_js_1.ValidationError(`prisma-compat: unknown field "${key}" in \`${clause}\` on ${modelName(ctx, mm)}.${op}().` +
         (suggestion ? ` Did you mean "${suggestion}"?` : '') +
         ` Known fields: ${known.join(', ') || '(none)'}.`);
 }
@@ -885,10 +885,10 @@ function resolveWriteProjection(ctx, mm, op, args) {
     const select = args.select;
     const omitArg = args.omit;
     if (include && select) {
-        throw new errors_js_1.ValidationError('[turbine] prisma-compat: `include` and `select` are mutually exclusive.');
+        throw new errors_js_1.ValidationError('prisma-compat: `include` and `select` are mutually exclusive.');
     }
     if (select && omitArg) {
-        throw new errors_js_1.ValidationError('[turbine] prisma-compat: `select` and `omit` are mutually exclusive. ' +
+        throw new errors_js_1.ValidationError('prisma-compat: `select` and `omit` are mutually exclusive. ' +
             'A `select` already lists exactly the fields you want.');
     }
     if (include) {
@@ -922,7 +922,7 @@ function resolveWriteProjection(ctx, mm, op, args) {
             if (val === false || val == null)
                 continue;
             if (mm.relations[key]) {
-                throw new errors_js_1.ValidationError(`[turbine] prisma-compat: \`omit\` on model "${modelName(ctx, mm)}" takes scalar fields, but "${key}" ` +
+                throw new errors_js_1.ValidationError(`prisma-compat: \`omit\` on model "${modelName(ctx, mm)}" takes scalar fields, but "${key}" ` +
                     'is a relation.');
             }
             assertWriteProjectionField(ctx, mm, op, 'omit', key);
@@ -1805,7 +1805,7 @@ function makeDelegate(ctx, mm, getQI, runInTx) {
     };
     const requireWhere = (args, op) => {
         if (!args || args.where === undefined) {
-            throw new errors_js_1.ValidationError(`[turbine] prisma-compat: ${op} on "${modelName(ctx, mm)}" requires a \`where\`.`);
+            throw new errors_js_1.ValidationError(`prisma-compat: ${op} on "${modelName(ctx, mm)}" requires a \`where\`.`);
         }
         return args;
     };
@@ -1971,7 +1971,7 @@ function makeDelegate(ctx, mm, getQI, runInTx) {
 function poolOf(db) {
     const pool = db.pool;
     if (!pool)
-        throw new errors_js_1.ValidationError('[turbine] prisma-compat: raw SQL needs a TurbineClient with an active pool.');
+        throw new errors_js_1.ValidationError('prisma-compat: raw SQL needs a TurbineClient with an active pool.');
     return pool;
 }
 function placeholderOf(db) {
@@ -2164,7 +2164,7 @@ const EMPTY_EXTENSIONS = { client: {}, model: new Map(), allModels: {} };
  */
 function applyExtension(prev, ext, modelKeys, clientKeys) {
     if (typeof ext !== 'object' || ext === null) {
-        throw new errors_js_1.ValidationError('[turbine] prisma-compat: $extends expects an extension object or a function ' +
+        throw new errors_js_1.ValidationError('prisma-compat: $extends expects an extension object or a function ' +
             `(Prisma.defineExtension callback form), received ${ext === null ? 'null' : typeof ext}.`);
     }
     for (const [component, value] of Object.entries(ext)) {
@@ -2182,7 +2182,7 @@ function applyExtension(prev, ext, modelKeys, clientKeys) {
     const client = { ...prev.client };
     for (const [name, member] of Object.entries(ext.client ?? {})) {
         if (clientKeys.has(name)) {
-            throw new errors_js_1.ValidationError(`[turbine] prisma-compat: $extends \`client\` member "${name}" would shadow an existing client ` +
+            throw new errors_js_1.ValidationError(`prisma-compat: $extends \`client\` member "${name}" would shadow an existing client ` +
                 'member (a model delegate or a client-level method). Rename it.');
         }
         client[name] = member;
@@ -2196,7 +2196,7 @@ function applyExtension(prev, ext, modelKeys, clientKeys) {
         }
         const canonical = modelKeys.get(key);
         if (!canonical) {
-            throw new errors_js_1.ValidationError(`[turbine] prisma-compat: $extends \`model\` key "${key}" is not a model on this client. ` +
+            throw new errors_js_1.ValidationError(`prisma-compat: $extends \`model\` key "${key}" is not a model on this client. ` +
                 `Known models: ${[...new Set(modelKeys.values())].sort().join(', ') || '(none)'}.`);
         }
         model.set(canonical, { ...(model.get(canonical) ?? {}), ...members });
@@ -2302,7 +2302,7 @@ function createPrismaCompatClient(client, map, options = {}) {
      */
     const txRunRaw = (tx) => async (text, params) => {
         if (typeof tx.rawQuery !== 'function') {
-            throw decorate(new errors_js_1.ValidationError('[turbine] prisma-compat: raw SQL inside $transaction needs a transaction client that can execute it ' +
+            throw decorate(new errors_js_1.ValidationError('prisma-compat: raw SQL inside $transaction needs a transaction client that can execute it ' +
                 '(core TransactionClient.rawQuery). Refusing to run the statement on a pool connection, which would ' +
                 'silently place it outside the transaction.'), ctx.options.prismaErrorCodes);
         }
@@ -2347,7 +2347,7 @@ function createPrismaCompatClient(client, map, options = {}) {
                             const batchables = arg.map((p, i) => {
                                 const b = batchableOf(p);
                                 if (!b) {
-                                    throw new errors_js_1.ValidationError(`[turbine] prisma-compat: $transaction([...]) item ${i} is not a lazy model call. Pass un-awaited delegate calls (e.g. prisma.User.create(...)).`);
+                                    throw new errors_js_1.ValidationError(`prisma-compat: $transaction([...]) item ${i} is not a lazy model call. Pass un-awaited delegate calls (e.g. prisma.User.create(...)).`);
                                 }
                                 return b;
                             });

package/dist/cjs/query/aggregates.js

@@ -80,7 +80,7 @@ function assertAggregatePiiOptIn(table, meta, field, column, usage, includePii)
     const colMeta = meta.columns.find((c) => c.name === column);
     if (!colMeta?.pii)
         return;
-    throw new errors_js_1.ValidationError(`[turbine] ${usage} on column "${field}" of table "${table}" is refused: that column is ` +
+    throw new errors_js_1.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'). " +
@@ -144,7 +144,7 @@ function buildGroupBy(qi, args) {
     const usedResultKeys = new Set();
     const claimResultKey = (key, what) => {
         if (key === '_count' || usedResultKeys.has(key)) {
-            throw new errors_js_1.ValidationError(`[turbine] groupBy output name "${key}" (${what}) collides with another output column on table ` +
+            throw new errors_js_1.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);
@@ -267,7 +267,7 @@ function buildGroupBy(qi, args) {
             }
             const alwaysNumeric = aggKey === '_sum' || aggKey === '_avg';
             if (alwaysNumeric && target.type === 'text') {
-                throw new errors_js_1.ValidationError(`[turbine] groupBy ${aggKey} target "${key}" on table "${qi.table}": ` +
+                throw new errors_js_1.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';
@@ -489,7 +489,7 @@ function buildGroupByOrderBy(qi, orderBy, byOrderExprs, aggOrderExprs) {
             if (key === '_count') {
                 const expr = aggOrderExprs.get('_count');
                 if (!expr) {
-                    throw new errors_js_1.ValidationError(`[turbine] Cannot order groupBy by "_count" on table "${qi.table}": _count is not selected. ` +
+                    throw new errors_js_1.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,
@@ -500,7 +500,7 @@ 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 errors_js_1.ValidationError(`[turbine] Invalid groupBy orderBy for "${key}" on table "${qi.table}": ` +
+                throw new errors_js_1.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)) {
@@ -512,7 +512,7 @@ function buildGroupByOrderBy(qi, orderBy, byOrderExprs, aggOrderExprs) {
                 const expr = aggOrderExprs.get(`${key}:${field}`) ??
                     (canonical === undefined ? undefined : aggOrderExprs.get(`${key}:${canonical}`));
                 if (!expr) {
-                    throw new errors_js_1.ValidationError(`[turbine] Cannot order groupBy by "${key}.${field}" on table "${qi.table}": ` +
+                    throw new errors_js_1.ValidationError(`Cannot order groupBy by "${key}.${field}" on table "${qi.table}": ` +
                         `that aggregate is not requested in this call. Orderable keys: ${validKeys()}.`);
                 }
                 (0, types_js_1.assertOrderDirection)(dirSpec, `groupBy orderBy "${key}.${field}" on table "${qi.table}"`);
@@ -523,8 +523,7 @@ 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 errors_js_1.ValidationError(`[turbine] Unknown field "${key}" in groupBy orderBy on table "${qi.table}". ` +
-                `Orderable keys: ${validKeys()}.`);
+            throw new errors_js_1.ValidationError(`Unknown field "${key}" in groupBy orderBy on table "${qi.table}". ` + `Orderable keys: ${validKeys()}.`);
         }
         (0, types_js_1.assertOrderDirection)(value, `groupBy orderBy "${key}" on table "${qi.table}"`);
         pushOrderTerm(expr, key, value);
@@ -538,18 +537,18 @@ function buildGroupByOrderBy(qi, orderBy, byOrderExprs, aggOrderExprs) {
  */
 function resolveJsonPathTarget(qi, context, field, path) {
     if (typeof field !== 'string') {
-        throw new errors_js_1.ValidationError(`[turbine] groupBy ${context} on table "${qi.table}" requires a string \`field\`.`);
+        throw new errors_js_1.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 errors_js_1.ValidationError(`[turbine] groupBy ${context} on "${field}" (table "${qi.table}") requires a non-empty \`path\` ` +
+        throw new errors_js_1.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 errors_js_1.ValidationError(`[turbine] groupBy ${context} on "${field}": column "${col}" on table "${qi.table}" is not a JSON ` +
+        throw new errors_js_1.ValidationError(`groupBy ${context} on "${field}": column "${col}" on table "${qi.table}" is not a JSON ` +
             `column (actual type: ${colType}).`);
     }
     return col;
@@ -573,11 +572,11 @@ function buildDistinctOnSource(qi, distinctOn, whereSql, params) {
         throw new errors_js_1.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 errors_js_1.ValidationError(`[turbine] groupBy distinctOn on table "${qi.table}" requires a non-empty \`columns\` array.`);
+        throw new errors_js_1.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 errors_js_1.ValidationError(`[turbine] groupBy distinctOn on table "${qi.table}" requires \`orderBy\` to pick ONE row per ` +
+        throw new errors_js_1.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
@@ -597,7 +596,7 @@ function buildDistinctOnSource(qi, distinctOn, whereSql, params) {
             continue;
         }
         if ((0, filters_js_1.isVectorOrderBy)(value) || qi.isRelationOrderByValue(value)) {
-            throw new errors_js_1.ValidationError(`[turbine] groupBy distinctOn.orderBy on "${key}" (table "${qi.table}") supports plain columns, ` +
+            throw new errors_js_1.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);
@@ -711,7 +710,7 @@ function splitHavingField(qi, field, value) {
             aggEntries.push({ key: k, fn, filter: v });
         }
         else if (k.startsWith('_')) {
-            throw new errors_js_1.ValidationError(`[turbine] Unknown aggregate "${k}" in having for field "${field}" on table "${qi.table}". ` +
+            throw new errors_js_1.ValidationError(`Unknown aggregate "${k}" in having for field "${field}" on table "${qi.table}". ` +
                 `Supported: ${Object.keys(HAVING_AGGREGATE_FNS).join(', ')}.`);
         }
         else {
@@ -747,7 +746,7 @@ function buildHavingCombinator(qi, key, value, params, jsonAggExprs, groupKeys,
     const parts = [];
     for (const condition of conditions) {
         if (!(0, filters_js_1.isUnmatchedPlainObject)(condition)) {
-            throw new errors_js_1.ValidationError(`[turbine] Invalid having "${key}" on table "${qi.table}": expected ` +
+            throw new errors_js_1.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);
@@ -788,7 +787,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 errors_js_1.ValidationError(`[turbine] having on "${field}" (table "${qi.table}") filters the grouped value itself, but ` +
+        throw new errors_js_1.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 } } }).`);
@@ -808,7 +807,7 @@ function buildHavingScalarClauses(qi, field, value, params, groupKeys) {
         clauses.push(...whereMod.buildOperatorClauses(qi, ref.expr, value, params));
     }
     else if ((0, filters_js_1.isUnmatchedPlainObject)(value)) {
-        throw new errors_js_1.ValidationError(`[turbine] Unknown operator${Object.keys(value).length > 1 ? 's' : ''} ` +
+        throw new errors_js_1.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}".`);
@@ -828,7 +827,7 @@ function buildHavingScalarClauses(qi, field, value, params, groupKeys) {
  */
 function buildHavingNumericClauses(qi, expr, filter, params) {
     if (filter === null) {
-        throw new errors_js_1.ValidationError(`[turbine] Invalid having filter on "${expr}" for table "${qi.table}": expected a value or operator object.`);
+        throw new errors_js_1.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) {
@@ -839,7 +838,7 @@ 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 errors_js_1.ValidationError(`[turbine] Unknown having operator "${k}" on "${expr}" for table "${qi.table}". ` +
+            throw new errors_js_1.ValidationError(`Unknown having operator "${k}" on "${expr}" for table "${qi.table}". ` +
                 `Supported: ${[...allowedKeys].join(', ')}.`);
         }
     }

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

@@ -428,11 +428,11 @@ function resolveCountRelations(parentMeta, countSpec) {
             continue;
         const rel = (0, utils_js_1.ownLookup)(parentMeta.relations, relName);
         if (!rel) {
-            throw new errors_js_1.RelationError(`[turbine] Unknown relation "${relName}" in _count on table "${parentMeta.name}". ` +
+            throw new errors_js_1.RelationError(`Unknown relation "${relName}" in _count on table "${parentMeta.name}". ` +
                 (0, utils_js_1.availableClause)(Object.keys(parentMeta.relations), 'It has no relations.'));
         }
         if (!isToMany(rel)) {
-            throw new errors_js_1.ValidationError(`[turbine] _count is only supported for to-many relations; "${relName}" on ` +
+            throw new errors_js_1.ValidationError(`_count is only supported for to-many relations; "${relName}" on ` +
                 `"${parentMeta.name}" is a to-one relation.`);
         }
         out.push(rel);
@@ -462,7 +462,7 @@ function rejectNestedPickOrder(withClause) {
         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 ` +
+                    throw new errors_js_1.ValidationError(`Pick-row ordering on relation "${key}" is only supported in a top-level ` +
                         'findMany orderBy: nested `with` orderBy does not support it.');
                 }
             }
@@ -504,7 +504,7 @@ async function loadRelationsBatched(ctx, parents, withClause, timeout, depth = 0
             // 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 errors_js_1.RelationError(`[turbine] Unknown relation "${relName}" on table "${ctx.parentMeta.name}". ` +
+            throw new errors_js_1.RelationError(`Unknown relation "${relName}" on table "${ctx.parentMeta.name}". ` +
                 (0, utils_js_1.availableClause)(Object.keys(ctx.parentMeta.relations), 'It has no relations.'));
         }
         resolved.push({ relName, rel, options: spec === true ? {} : spec });
@@ -532,7 +532,7 @@ async function loadRelationsBatched(ctx, parents, withClause, timeout, depth = 0
     // 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 errors_js_1.RelationError(`[turbine] Unknown relation "_count" on table "${ctx.parentMeta.name}". ` +
+        throw new errors_js_1.RelationError(`Unknown relation "_count" on table "${ctx.parentMeta.name}". ` +
             `${(0, utils_js_1.availableClause)(Object.keys(ctx.parentMeta.relations), 'It has no relations.')} ` +
             '(`_count` is supported on the top-level `with` only, on every relationLoadStrategy.)');
     }
@@ -814,7 +814,7 @@ function stripRankColumn(result) {
 async function loadManyToMany(ctx, parents, rel, relName, options, timeout, depth, path) {
     const through = rel.through;
     if (!through) {
-        throw new errors_js_1.ValidationError(`[turbine] manyToMany relation "${relName}" is missing its junction (\`through\`).`);
+        throw new errors_js_1.ValidationError(`manyToMany relation "${relName}" is missing its junction (\`through\`).`);
     }
     const sourceJ = (0, schema_js_1.normalizeKeyColumns)(through.sourceKey);
     const targetJ = (0, schema_js_1.normalizeKeyColumns)(through.targetKey);
@@ -972,7 +972,7 @@ async function loadOneCount(ctx, parents, rel) {
     if (rel.type === 'manyToMany') {
         const through = rel.through;
         if (!through) {
-            throw new errors_js_1.ValidationError(`[turbine] manyToMany relation "${rel.name}" is missing its junction (\`through\`).`);
+            throw new errors_js_1.ValidationError(`manyToMany relation "${rel.name}" is missing its junction (\`through\`).`);
         }
         const sourceRef = (0, schema_js_1.normalizeKeyColumns)(rel.referenceKey);
         const sourceJ = (0, schema_js_1.normalizeKeyColumns)(through.sourceKey);
@@ -1157,6 +1157,6 @@ function groupBy(rows, field) {
 function requireTable(schema, table, relName) {
     const meta = schema.tables[table];
     if (!meta)
-        throw new errors_js_1.RelationError(`[turbine] Unknown relation target "${table}" (relation "${relName}").`);
+        throw new errors_js_1.RelationError(`Unknown relation target "${table}" (relation "${relName}").`);
     return meta;
 }

package/dist/cjs/query/builder.js

@@ -707,7 +707,7 @@ class QueryInterface {
         this.schema = schema;
         const meta = schema.tables[table];
         if (!meta) {
-            throw new errors_js_1.ValidationError(`[turbine] Unknown table "${table}". ${(0, utils_js_1.availableClause)(Object.keys(schema.tables), 'The schema has no tables.')}`);
+            throw new errors_js_1.ValidationError(`Unknown table "${table}". ${(0, utils_js_1.availableClause)(Object.keys(schema.tables), 'The schema has no tables.')}`);
         }
         this.tableMeta = meta;
         this.middlewares = middlewares ?? [];
@@ -1008,7 +1008,7 @@ class QueryInterface {
     paginationValue(value, arg) {
         const n = Number(value);
         if (!Number.isSafeInteger(n) || n < 0) {
-            throw new errors_js_1.ValidationError(`[turbine] ${arg} on "${this.table}" must be a non-negative integer, received: ${String(value)}`);
+            throw new errors_js_1.ValidationError(`${arg} on "${this.table}" must be a non-negative integer, received: ${String(value)}`);
         }
         return n;
     }
@@ -1092,7 +1092,7 @@ class QueryInterface {
             return this.currentJsonEncoding;
         }
         if (!JSON_ENCODINGS.includes(argEncoding)) {
-            throw new errors_js_1.ValidationError(`[turbine] Invalid \`jsonEncoding\` on "${this.table}": ${JSON.stringify(argEncoding)}. ` +
+            throw new errors_js_1.ValidationError(`Invalid \`jsonEncoding\` on "${this.table}": ${JSON.stringify(argEncoding)}. ` +
                 `Expected ${JSON_ENCODINGS.map((e) => `'${e}'`).join(' or ')}.`);
         }
         this.currentJsonEncoding = argEncoding;
@@ -1920,7 +1920,7 @@ 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')}`;
@@ -2014,7 +2014,7 @@ 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 errors_js_1.ValidationError('[turbine] forceCustomPlan: true cannot be honoured on a client configured with ' +
+            throw new errors_js_1.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 ' +
@@ -2258,7 +2258,7 @@ 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 errors_js_1.ValidationError(`[turbine] findUnique on "${this.table}" refused: the \`where\` clause has no predicate, ` +
+            throw new errors_js_1.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`.');
@@ -2699,7 +2699,7 @@ class QueryInterface {
         if (args?.distinct && args.distinct.length > 0 && args.orderBy) {
             for (const [, d] of (0, filters_js_1.orderByEntries)(args.orderBy)) {
                 if (this.isRelationOrderByValue(d)) {
-                    throw new errors_js_1.ValidationError('[turbine] `distinct` cannot be combined with relation orderBy (pick-row, `_count`, or ' +
+                    throw new errors_js_1.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.');
                 }
             }
@@ -2896,7 +2896,7 @@ class QueryInterface {
                 // the user's order (picks the right representative row), outer re-ordered
                 // by the user's order alone.
                 if ((0, filters_js_1.orderByEntries)(args.orderBy).some(([, d]) => (0, filters_js_1.isVectorOrderBy)(d))) {
-                    throw new errors_js_1.ValidationError('[turbine] `distinct` cannot be combined with vector distance ordering.');
+                    throw new errors_js_1.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/cjs/query/compound-unique.js

@@ -185,7 +185,7 @@ function expandCompoundUniqueWhere(meta, where) {
             providedByColumn.size === expected.size &&
             [...providedByColumn.keys()].every((c) => expected.has(c));
         if (!exact) {
-            throw new errors_js_1.ValidationError(`[turbine] Compound unique selector "${key}" on table "${meta.name}" must supply exactly ` +
+            throw new errors_js_1.ValidationError(`Compound unique selector "${key}" on table "${meta.name}" must supply exactly ` +
                 `{ ${fields.join(', ')} }, received { ${provided.join(', ') || '(none)'} }.`);
         }
         result ??= { ...where };
@@ -242,7 +242,7 @@ 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 errors_js_1.ValidationError(`[turbine] findUnique on "${table}" refused: the \`where\` clause does not identify a single row, ` +
+    throw new errors_js_1.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}`);
 }
 function uniqueKeyNames(meta) {

package/dist/cjs/query/filters.js

@@ -165,7 +165,7 @@ function fingerprintOperatorShape(value) {
 function assertBindableEqualsOperand(value, column) {
     if (!isUnmatchedPlainObject(value))
         return;
-    throw new errors_js_1.ValidationError(`[turbine] Plain-object value for operator 'equals' on ${column}: ` +
+    throw new errors_js_1.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.`);
 }