turbine-orm 0.76.0 → 0.77.0

package/dist/nested-write.js

@@ -214,11 +214,11 @@ function keyOf(value) {
 function validateOps(relationName, ops, isUpdate) {
     for (const opName of Object.keys(ops)) {
         if (!CREATE_ONLY_OPS.has(opName) && !UPDATE_ONLY_OPS.has(opName)) {
-            throw new ValidationError(`[turbine] Unknown nested write operation "${opName}" on relation "${relationName}". ` +
+            throw new ValidationError(`Unknown nested write operation "${opName}" on relation "${relationName}". ` +
                 `Valid operations: create, connect, connectOrCreate${isUpdate ? ', disconnect, set, delete, update, upsert' : ''}.`);
         }
         if (!isUpdate && UPDATE_ONLY_OPS.has(opName)) {
-            throw new ValidationError(`[turbine] Operation "${opName}" on relation "${relationName}" is only valid inside update(), not create().`);
+            throw new ValidationError(`Operation "${opName}" on relation "${relationName}" is only valid inside update(), not create().`);
         }
     }
 }
@@ -237,7 +237,7 @@ function pkWhere(tableMeta, row) {
         // be one this engine just read, so a missing member is an internal fault,
         // and the only safe response is to refuse rather than to run.
         if (row[field] === undefined) {
-            throw new ValidationError(`[turbine] Cannot address a row of "${tableMeta.name}" by primary key: "${field}" is missing from the ` +
+            throw new ValidationError(`Cannot address a row of "${tableMeta.name}" by primary key: "${field}" is missing from the ` +
                 'row this nested write is operating on, so the generated predicate would match more rows than intended. ' +
                 'This is a bug in turbine, please report it.');
         }
@@ -339,7 +339,7 @@ function assertTargetSelectsSomething(target, op, relName, rel) {
     if (target === true) {
         if (toOne)
             return;
-        throw new ValidationError(`[turbine] Nested ${op} on to-many relation "${relName}" needs a "where" selector: ` +
+        throw new ValidationError(`Nested ${op} on to-many relation "${relName}" needs a "where" selector: ` +
             `"${op}: true" would ${op} every related "${rel.to}" row.`);
     }
     if (target && typeof target === 'object' && !Array.isArray(target)) {
@@ -347,7 +347,7 @@ function assertTargetSelectsSomething(target, op, relName, rel) {
         if (bound)
             return;
     }
-    throw new ValidationError(`[turbine] Nested ${op} on relation "${relName}" requires a selector with at least one defined value. ` +
+    throw new ValidationError(`Nested ${op} on relation "${relName}" requires a selector with at least one defined value. ` +
         `An empty or all-undefined "where" would ${op} every related "${rel.to}" row of this parent.`);
 }
 /**
@@ -386,7 +386,7 @@ function junctionAccessorHint(junction) {
  */
 function manyToManyOpUnsupported(op, relName, rel) {
     const junction = rel.through?.table ?? 'junction';
-    return new ValidationError(`[turbine] Nested "${op}" is not supported on the many-to-many relation "${relName}" ` +
+    return new ValidationError(`Nested "${op}" is not supported on the many-to-many relation "${relName}" ` +
         `(via the "${junction}" junction table). The supported many-to-many nested operations are ` +
         `connect, disconnect and set. To ${op} a "${rel.to}" row itself, write it directly on the ` +
         `"${rel.to}" table inside the same $transaction and link it with a nested connect; to write ` +
@@ -424,24 +424,24 @@ function junctionPairIsUnique(junctionMeta, sourceCol, targetCol) {
 function junctionPlan(ctx, rel, relName, parentRow) {
     const through = rel.through;
     if (!through) {
-        throw new ValidationError(`[turbine] manyToMany relation "${relName}" is missing a \`through\` junction descriptor.`);
+        throw new ValidationError(`manyToMany relation "${relName}" is missing a \`through\` junction descriptor.`);
     }
     const junctionMeta = ctx.schema.tables[through.table];
     if (!junctionMeta) {
-        throw new ValidationError(`[turbine] Nested write on the many-to-many relation "${relName}": junction table ` +
+        throw new ValidationError(`Nested write on the many-to-many relation "${relName}": junction table ` +
             `"${through.table}" is not present in the schema metadata, so its rows cannot be written. ` +
             `Regenerate the schema (turbine generate) so the junction table is included.`);
     }
     const targetMeta = ctx.schema.tables[rel.to];
     if (!targetMeta) {
-        throw new ValidationError(`[turbine] Nested write on the many-to-many relation "${relName}": unknown target table "${rel.to}".`);
+        throw new ValidationError(`Nested write on the many-to-many relation "${relName}": unknown target table "${rel.to}".`);
     }
     const sourceKeys = normalizeKeyColumns(through.sourceKey);
     const targetKeys = normalizeKeyColumns(through.targetKey);
     const refKeys = normalizeKeyColumns(rel.referenceKey);
     const targetPk = targetMeta.primaryKey;
     if (sourceKeys.length !== 1 || targetKeys.length !== 1 || refKeys.length !== 1 || targetPk.length !== 1) {
-        throw new ValidationError(`[turbine] Nested writes on the many-to-many relation "${relName}" (via "${through.table}") support ` +
+        throw new ValidationError(`Nested writes on the many-to-many relation "${relName}" (via "${through.table}") support ` +
             `single-column junction keys only; this relation links on composite keys ` +
             `(source ${sourceKeys.length}, target ${targetKeys.length}, target primary key ${targetPk.length} column(s)). ` +
             `Write the junction rows directly inside the same $transaction: ${junctionAccessorHint(through.table)}.`);
@@ -454,7 +454,7 @@ function junctionPlan(ctx, rel, relName, parentRow) {
     // key at all. Introspection can never produce this (it requires two distinct
     // FK columns), but a hand-declared `defineSchema` manyToMany can.
     if (sourceKeys[0] === targetKeys[0]) {
-        throw new ValidationError(`[turbine] Nested write on the many-to-many relation "${relName}" cannot run: the junction ` +
+        throw new ValidationError(`Nested write on the many-to-many relation "${relName}" cannot run: the junction ` +
             `"${through.table}" names the same column "${sourceKeys[0]}" as BOTH its sourceKey and its ` +
             `targetKey, so a link row cannot hold the parent key and the target key at once. Fix the ` +
             `relation's \`through\` descriptor to name the two distinct junction columns.`);
@@ -462,7 +462,7 @@ function junctionPlan(ctx, rel, relName, parentRow) {
     const parentField = ctx.schema.tables[rel.from]?.reverseColumnMap[refKeys[0]] ?? refKeys[0];
     const parentValue = parentRow[parentField];
     if (parentValue === null || parentValue === undefined) {
-        throw new ValidationError(`[turbine] Nested write on the many-to-many relation "${relName}" cannot run: the parent's reference ` +
+        throw new ValidationError(`Nested write on the many-to-many relation "${relName}" cannot run: the parent's reference ` +
             `key "${parentField}" is ${parentValue === null ? 'null' : 'missing from the loaded row'}, so no ` +
             `junction row can be correlated to this parent.`);
     }
@@ -477,7 +477,7 @@ function junctionPlan(ctx, rel, relName, parentRow) {
 }
 /** The E003 for a target selector that matched no row. */
 function noTargetRow(op, relName, rel, target) {
-    return new ValidationError(`[turbine] Nested ${op} on the many-to-many relation "${relName}": no "${rel.to}" row found ` +
+    return new ValidationError(`Nested ${op} on the many-to-many relation "${relName}": no "${rel.to}" row found ` +
         `matching ${describeTargetForMessage(target)}.`);
 }
 /**
@@ -536,7 +536,7 @@ async function resolveJunctionTargets(ctx, rel, relName, plan, op, items) {
             throw noTargetRow(op, relName, rel, target);
         const value = row[plan.targetKeyField];
         if (value === null || value === undefined) {
-            throw new ValidationError(`[turbine] Nested ${op} on the many-to-many relation "${relName}": the "${rel.to}" row matching ` +
+            throw new ValidationError(`Nested ${op} on the many-to-many relation "${relName}": the "${rel.to}" row matching ` +
                 `${describeTargetForMessage(target)} has no "${plan.targetKeyField}" value to link.`);
         }
         const key = keyOf(value);
@@ -735,7 +735,7 @@ function notRelatedToParent(op, relName, rel, target) {
         table: rel.to,
         where: target,
         operation: `nested ${op}`,
-        message: `[turbine] Nested ${op} on relation "${relName}": no "${rel.to}" record matching ` +
+        message: `Nested ${op} on relation "${relName}": no "${rel.to}" record matching ` +
             `${describeTargetForMessage(target)} is related to this parent. Either it does not exist, ` +
             `or it belongs to a different parent (a nested ${op} can only touch this parent's rows).`,
     });
@@ -769,14 +769,14 @@ export async function executeNestedCreate(ctx, tableName, data, depth = 0, path
     }
     const tableMeta = ctx.schema.tables[tableName];
     if (!tableMeta) {
-        throw new ValidationError(`[turbine] Unknown table "${tableName}".`);
+        throw new ValidationError(`Unknown table "${tableName}".`);
     }
     const { scalars, relations } = extractRelationFields(data, tableMeta);
     // Validate all relation operations
     for (const [relName, ops] of Object.entries(relations)) {
         const rel = tableMeta.relations[relName];
         if (!rel) {
-            throw new RelationError(`[turbine] Unknown relation "${relName}" on table "${tableName}". ` +
+            throw new RelationError(`Unknown relation "${relName}" on table "${tableName}". ` +
                 `Available relations: ${Object.keys(tableMeta.relations).join(', ') || '(none)'}.`);
         }
         validateOps(relName, ops, false);
@@ -848,14 +848,14 @@ export async function executeNestedUpdate(ctx, tableName, where, data, depth = 0
     }
     const tableMeta = ctx.schema.tables[tableName];
     if (!tableMeta) {
-        throw new ValidationError(`[turbine] Unknown table "${tableName}".`);
+        throw new ValidationError(`Unknown table "${tableName}".`);
     }
     const { scalars, relations } = extractRelationFields(data, tableMeta);
     // Validate all relation operations
     for (const [relName, ops] of Object.entries(relations)) {
         const rel = tableMeta.relations[relName];
         if (!rel) {
-            throw new RelationError(`[turbine] Unknown relation "${relName}" on table "${tableName}". ` +
+            throw new RelationError(`Unknown relation "${relName}" on table "${tableName}". ` +
                 `Available relations: ${Object.keys(tableMeta.relations).join(', ') || '(none)'}.`);
         }
         validateOps(relName, ops, true);
@@ -868,7 +868,7 @@ export async function executeNestedUpdate(ctx, tableName, where, data, depth = 0
     else {
         parentRow = (await ctx.tx.table(tableName).findUnique({ where }));
         if (!parentRow) {
-            throw new ValidationError(`[turbine] update: no ${tableName} row found matching ${describeTargetForMessage(where)}.`);
+            throw new ValidationError(`update: no ${tableName} row found matching ${describeTargetForMessage(where)}.`);
         }
     }
     // Process each relation
@@ -916,7 +916,7 @@ export async function executeNestedUpdate(ctx, tableName, where, data, depth = 0
                     return col?.nullable ?? false;
                 });
                 if (!nullable) {
-                    throw new ValidationError(`[turbine] Cannot disconnect "${relName}": foreign key column(s) ${fks.join(', ')} are NOT NULL. Use delete instead.`);
+                    throw new ValidationError(`Cannot disconnect "${relName}": foreign key column(s) ${fks.join(', ')} are NOT NULL. Use delete instead.`);
                 }
                 const updateData = {};
                 for (const fk of fks) {
@@ -1025,7 +1025,7 @@ async function resolveBelongsToForCreate(ctx, rel, ops, parentTable, depth, path
             const target = items[0];
             relatedRow = (await ctx.tx.table(rel.to).findUnique({ where: target }));
             if (!relatedRow) {
-                throw new ValidationError(`[turbine] connect on "${relName}": no ${rel.to} row found matching ${describeTargetForMessage(target)}.`);
+                throw new ValidationError(`connect on "${relName}": no ${rel.to} row found matching ${describeTargetForMessage(target)}.`);
             }
         }
     }
@@ -1080,7 +1080,7 @@ async function processBelongsToCreate(ctx, rel, ops, parentRow, parentTable, dep
             const target = items[0];
             const existing = await ctx.tx.table(rel.to).findUnique({ where: target });
             if (!existing) {
-                throw new ValidationError(`[turbine] connect on "${relName}": no ${rel.to} row found matching ${describeTargetForMessage(target)}.`);
+                throw new ValidationError(`connect on "${relName}": no ${rel.to} row found matching ${describeTargetForMessage(target)}.`);
             }
             const updateData = {};
             const relatedTable = ctx.schema.tables[rel.to];
@@ -1130,7 +1130,7 @@ function assertConnectInScope(ctx, rel, child, parentRow, target) {
             continue;
         if (current === key(parentRow[refField]))
             continue;
-        throw new ValidationError(`[turbine] connect refused: ${rel.to} row ${describeTargetForMessage(target)} is already owned by ` +
+        throw new ValidationError(`connect refused: ${rel.to} row ${describeTargetForMessage(target)} is already owned by ` +
             `another "${rel.from}" (its ${fks[i]} is ${current}). \`scopedConnect\` only allows connecting a row ` +
             `that is unowned or already owned by this parent; re-parenting must be an explicit update.`);
     }
@@ -1145,7 +1145,7 @@ async function batchConnect(ctx, rel, items, parentRow) {
     for (const target of items) {
         const existing = await ctx.tx.table(rel.to).findUnique({ where: target });
         if (!existing) {
-            throw new ValidationError(`[turbine] connect: no ${rel.to} row found matching ${describeTargetForMessage(target)}.`);
+            throw new ValidationError(`connect: no ${rel.to} row found matching ${describeTargetForMessage(target)}.`);
         }
         assertConnectInScope(ctx, rel, existing, parentRow, target);
     }
@@ -1197,7 +1197,7 @@ async function processDisconnect(ctx, rel, disconnectArg, relName, parentRow) {
         return col?.nullable ?? false;
     });
     if (!nullable) {
-        throw new ValidationError(`[turbine] Cannot disconnect "${relName}": foreign key column(s) ${fks.join(', ')} on "${rel.to}" are NOT NULL. Use delete instead.`);
+        throw new ValidationError(`Cannot disconnect "${relName}": foreign key column(s) ${fks.join(', ')} on "${rel.to}" are NOT NULL. Use delete instead.`);
     }
     const items = toArray(disconnectArg);
     if (items.length === 0)
@@ -1240,7 +1240,7 @@ async function processSet(ctx, rel, setItems, parentRow) {
         const refField = ctx.schema.tables[rel.from]?.reverseColumnMap[refs[i]] ?? refs[i];
         const value = parentRow[refField];
         if (value === null || value === undefined) {
-            throw new ValidationError(`[turbine] Nested set on relation "${rel.name}" cannot run: the parent's reference key ` +
+            throw new ValidationError(`Nested set on relation "${rel.name}" cannot run: the parent's reference key ` +
                 `"${refField}" is ${value === null ? 'null' : 'missing from the loaded row'}, so no child rows ` +
                 `can be correlated to this parent.`);
         }
@@ -1278,7 +1278,7 @@ async function processNestedUpdate(ctx, rel, updateArg, relName, parentRow) {
     const correlation = parentCorrelationWhere(ctx, rel, parentRow);
     for (const item of items) {
         if (!item.where || !item.data) {
-            throw new ValidationError(`[turbine] Nested update on "${rel.name}" requires both "where" and "data" fields.`);
+            throw new ValidationError(`Nested update on "${rel.name}" requires both "where" and "data" fields.`);
         }
         assertTargetSelectsSomething(item.where, 'update', relName, rel);
         if (!correlation)
@@ -1302,7 +1302,7 @@ async function processNestedUpsert(ctx, rel, upsertArg, parentRow, relName) {
     const correlation = parentCorrelationWhere(ctx, rel, parentRow);
     for (const item of items) {
         if (!item.where || !item.create || !item.update) {
-            throw new ValidationError(`[turbine] Nested upsert on "${rel.name}" requires "where", "create", and "update" fields.`);
+            throw new ValidationError(`Nested upsert on "${rel.name}" requires "where", "create", and "update" fields.`);
         }
         assertTargetSelectsSomething(item.where, 'upsert', relName, rel);
         const scoped = correlation ? scopeWhereToParent(item.where, correlation) : null;
@@ -1324,7 +1324,7 @@ async function processNestedUpsert(ctx, rel, upsertArg, parentRow, relName) {
 async function processBelongsToUpdate(ctx, rel, updateArg, parentRow, parentTable) {
     const item = updateArg;
     if (!item.data) {
-        throw new ValidationError(`[turbine] Nested update on belongsTo "${rel.name}" requires a "data" field.`);
+        throw new ValidationError(`Nested update on belongsTo "${rel.name}" requires a "data" field.`);
     }
     // The related row is the one this parent's FK points at. Route through the
     // shared correlation helper (like every sibling operation) so a NULL parent
@@ -1346,7 +1346,7 @@ async function processBelongsToUpdate(ctx, rel, updateArg, parentRow, parentTabl
 async function processBelongsToUpsert(ctx, rel, upsertArg, parentRow, parentTable) {
     const item = upsertArg;
     if (!item.where || !item.create || !item.update) {
-        throw new ValidationError(`[turbine] Nested upsert on belongsTo "${rel.name}" requires "where", "create", and "update" fields.`);
+        throw new ValidationError(`Nested upsert on belongsTo "${rel.name}" requires "where", "create", and "update" fields.`);
     }
     // Scope the lookup to the row this parent actually points at. Without the
     // correlation, a `where` naming any other row would update a record with no

package/dist/observe.js

@@ -154,7 +154,7 @@ export class ObserveEngine {
     stopped = false;
     constructor(config) {
         if (!config.sink && !config.connectionString) {
-            throw new ValidationError('[turbine] ObserveEngine: neither `connectionString` nor `sink` was provided, so there is nowhere to ' +
+            throw new ValidationError('ObserveEngine: neither `connectionString` nor `sink` was provided, so there is nowhere to ' +
                 'flush metrics. Pass `connectionString` (a separate metrics database URL, often TURBINE_OBSERVE_URL) ' +
                 'or a custom `sink` implementing ObserveSink.');
         }

package/dist/pipeline-submittable.js

@@ -18,7 +18,7 @@
  */
 import Result from 'pg/lib/result';
 import { prepareValue } from 'pg/lib/utils';
-import { PipelineError, wrapPgError } from './errors.js';
+import { PipelineError, TimeoutError, wrapPgError } from './errors.js';
 // ---------------------------------------------------------------------------
 // Event names we intercept
 // ---------------------------------------------------------------------------
@@ -311,7 +311,11 @@ export async function runPipelined(client, queries, options = {}) {
         // -----------------------------------------------------------------------
         if (timeout && timeout > 0) {
             timeoutHandle = setTimeout(() => {
-                pipelineError = new Error(`[turbine] Pipeline timed out after ${timeout}ms`);
+                // TimeoutError (E002), matching $transaction({ timeout }). A bare Error
+                // here meant `pipeline({ timeout })` rejected with no .code, no
+                // .docsUrl, and failing `instanceof TurbineError`, so the two timeout
+                // paths in the same client disagreed about their own contract.
+                pipelineError = new TimeoutError(timeout, 'Pipeline');
                 if (connection.stream.destroy) {
                     connection.stream.destroy(pipelineError);
                 }

package/dist/pipeline.js

@@ -19,7 +19,7 @@
  * Hyperdrive), mock pools in tests, and any pool that doesn't expose pg internals.
  */
 import { postgresDialect } from './dialect.js';
-import { PipelineError, wrapPgError } from './errors.js';
+import { PipelineError, TurbineError, wrapPgError } from './errors.js';
 import { runPipelined, supportsExtendedPipeline } from './pipeline-submittable.js';
 /**
  * Execute queries sequentially on an already-acquired connection.
@@ -218,6 +218,14 @@ export async function executePipeline(pool, queries, options) {
         // keywords rather than Postgres's.
         return await runSequential(client, queries, poolDialect(pool), options);
     }
+    catch (err) {
+        // Already-typed Turbine errors pass through untouched; anything else is a
+        // driver error that must not escape with a SQLSTATE sitting in the same
+        // `.code` slot Turbine puts TURBINE_E0NN in.
+        if (err instanceof TurbineError)
+            throw err;
+        throw wrapPgError(err);
+    }
     finally {
         client.release();
     }

package/dist/powdb-introspect.d.ts

@@ -62,7 +62,7 @@
  * wired to a networked `exec`, and `cli/config.ts` teaching the generate
  * funnel to construct a PowDB client instead of a `pg` client for `powdb://`.
  */
-import { type PowdbCapabilities } from './powdb.js';
+import { type PowdbCapabilities } from './powdb-shared.js';
 import type { SchemaMetadata } from './schema.js';
 /** A minimal rows-returning executor over a PowDB connection (embedded or networked). */
 export type PowdbExec = (powql: string) => Promise<{

package/dist/powdb-introspect.js

@@ -64,7 +64,7 @@
  */
 import { ValidationError } from './errors.js';
 import { applyTableFilters } from './introspect.js';
-import { quotePowqlIdent, requireCapability } from './powdb.js';
+import { quotePowqlIdent, requireCapability } from './powdb-shared.js';
 import { singularize, snakeToCamel } from './schema.js';
 /** Coerce a wire cell to string (legacy wire cells are strings; native cells may be typed). */
 function asString(v) {
@@ -123,7 +123,7 @@ export async function introspectPowdbDatabase(exec, options = {}) {
     // every table filters out and the schema comes back silently empty. Refuse
     // that instead of losing data: real rows must carry a `name`.
     if (schemaRows.length > 0 && candidateTables.length === 0) {
-        throw new ValidationError(`[turbine] PowDB introspection: the \`schema\` statement returned ${schemaRows.length} row(s) but none carried a ` +
+        throw new ValidationError(`PowDB introspection: the \`schema\` statement returned ${schemaRows.length} row(s) but none carried a ` +
             '`name` cell. The `exec` you supplied likely returns POSITIONAL rows (string[][]) rather than records keyed by ' +
             'column name; zip `columns` with each row (see introspectPowdbDatabase docs).');
     }