turbine-orm 0.76.0 → 0.77.0

package/dist/cjs/nested-write.js

@@ -222,11 +222,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 errors_js_1.ValidationError(`[turbine] Unknown nested write operation "${opName}" on relation "${relationName}". ` +
+            throw new errors_js_1.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 errors_js_1.ValidationError(`[turbine] Operation "${opName}" on relation "${relationName}" is only valid inside update(), not create().`);
+            throw new errors_js_1.ValidationError(`Operation "${opName}" on relation "${relationName}" is only valid inside update(), not create().`);
         }
     }
 }
@@ -245,7 +245,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 errors_js_1.ValidationError(`[turbine] Cannot address a row of "${tableMeta.name}" by primary key: "${field}" is missing from the ` +
+            throw new errors_js_1.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.');
         }
@@ -347,7 +347,7 @@ function assertTargetSelectsSomething(target, op, relName, rel) {
     if (target === true) {
         if (toOne)
             return;
-        throw new errors_js_1.ValidationError(`[turbine] Nested ${op} on to-many relation "${relName}" needs a "where" selector: ` +
+        throw new errors_js_1.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)) {
@@ -355,7 +355,7 @@ function assertTargetSelectsSomething(target, op, relName, rel) {
         if (bound)
             return;
     }
-    throw new errors_js_1.ValidationError(`[turbine] Nested ${op} on relation "${relName}" requires a selector with at least one defined value. ` +
+    throw new errors_js_1.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.`);
 }
 /**
@@ -394,7 +394,7 @@ function junctionAccessorHint(junction) {
  */
 function manyToManyOpUnsupported(op, relName, rel) {
     const junction = rel.through?.table ?? 'junction';
-    return new errors_js_1.ValidationError(`[turbine] Nested "${op}" is not supported on the many-to-many relation "${relName}" ` +
+    return new errors_js_1.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 ` +
@@ -432,24 +432,24 @@ function junctionPairIsUnique(junctionMeta, sourceCol, targetCol) {
 function junctionPlan(ctx, rel, relName, parentRow) {
     const through = rel.through;
     if (!through) {
-        throw new errors_js_1.ValidationError(`[turbine] manyToMany relation "${relName}" is missing a \`through\` junction descriptor.`);
+        throw new errors_js_1.ValidationError(`manyToMany relation "${relName}" is missing a \`through\` junction descriptor.`);
     }
     const junctionMeta = ctx.schema.tables[through.table];
     if (!junctionMeta) {
-        throw new errors_js_1.ValidationError(`[turbine] Nested write on the many-to-many relation "${relName}": junction table ` +
+        throw new errors_js_1.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 errors_js_1.ValidationError(`[turbine] Nested write on the many-to-many relation "${relName}": unknown target table "${rel.to}".`);
+        throw new errors_js_1.ValidationError(`Nested write on the many-to-many relation "${relName}": unknown target table "${rel.to}".`);
     }
     const sourceKeys = (0, schema_js_1.normalizeKeyColumns)(through.sourceKey);
     const targetKeys = (0, schema_js_1.normalizeKeyColumns)(through.targetKey);
     const refKeys = (0, schema_js_1.normalizeKeyColumns)(rel.referenceKey);
     const targetPk = targetMeta.primaryKey;
     if (sourceKeys.length !== 1 || targetKeys.length !== 1 || refKeys.length !== 1 || targetPk.length !== 1) {
-        throw new errors_js_1.ValidationError(`[turbine] Nested writes on the many-to-many relation "${relName}" (via "${through.table}") support ` +
+        throw new errors_js_1.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)}.`);
@@ -462,7 +462,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 errors_js_1.ValidationError(`[turbine] Nested write on the many-to-many relation "${relName}" cannot run: the junction ` +
+        throw new errors_js_1.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.`);
@@ -470,7 +470,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 errors_js_1.ValidationError(`[turbine] Nested write on the many-to-many relation "${relName}" cannot run: the parent's reference ` +
+        throw new errors_js_1.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.`);
     }
@@ -485,7 +485,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 errors_js_1.ValidationError(`[turbine] Nested ${op} on the many-to-many relation "${relName}": no "${rel.to}" row found ` +
+    return new errors_js_1.ValidationError(`Nested ${op} on the many-to-many relation "${relName}": no "${rel.to}" row found ` +
         `matching ${(0, errors_js_1.describeTargetForMessage)(target)}.`);
 }
 /**
@@ -544,7 +544,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 errors_js_1.ValidationError(`[turbine] Nested ${op} on the many-to-many relation "${relName}": the "${rel.to}" row matching ` +
+            throw new errors_js_1.ValidationError(`Nested ${op} on the many-to-many relation "${relName}": the "${rel.to}" row matching ` +
                 `${(0, errors_js_1.describeTargetForMessage)(target)} has no "${plan.targetKeyField}" value to link.`);
         }
         const key = keyOf(value);
@@ -743,7 +743,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 ` +
             `${(0, errors_js_1.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).`,
     });
@@ -777,14 +777,14 @@ async function executeNestedCreate(ctx, tableName, data, depth = 0, path = []) {
     }
     const tableMeta = ctx.schema.tables[tableName];
     if (!tableMeta) {
-        throw new errors_js_1.ValidationError(`[turbine] Unknown table "${tableName}".`);
+        throw new errors_js_1.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 errors_js_1.RelationError(`[turbine] Unknown relation "${relName}" on table "${tableName}". ` +
+            throw new errors_js_1.RelationError(`Unknown relation "${relName}" on table "${tableName}". ` +
                 `Available relations: ${Object.keys(tableMeta.relations).join(', ') || '(none)'}.`);
         }
         validateOps(relName, ops, false);
@@ -856,14 +856,14 @@ async function executeNestedUpdate(ctx, tableName, where, data, depth = 0, path
     }
     const tableMeta = ctx.schema.tables[tableName];
     if (!tableMeta) {
-        throw new errors_js_1.ValidationError(`[turbine] Unknown table "${tableName}".`);
+        throw new errors_js_1.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 errors_js_1.RelationError(`[turbine] Unknown relation "${relName}" on table "${tableName}". ` +
+            throw new errors_js_1.RelationError(`Unknown relation "${relName}" on table "${tableName}". ` +
                 `Available relations: ${Object.keys(tableMeta.relations).join(', ') || '(none)'}.`);
         }
         validateOps(relName, ops, true);
@@ -876,7 +876,7 @@ async function executeNestedUpdate(ctx, tableName, where, data, depth = 0, path
     else {
         parentRow = (await ctx.tx.table(tableName).findUnique({ where }));
         if (!parentRow) {
-            throw new errors_js_1.ValidationError(`[turbine] update: no ${tableName} row found matching ${(0, errors_js_1.describeTargetForMessage)(where)}.`);
+            throw new errors_js_1.ValidationError(`update: no ${tableName} row found matching ${(0, errors_js_1.describeTargetForMessage)(where)}.`);
         }
     }
     // Process each relation
@@ -924,7 +924,7 @@ async function executeNestedUpdate(ctx, tableName, where, data, depth = 0, path
                     return col?.nullable ?? false;
                 });
                 if (!nullable) {
-                    throw new errors_js_1.ValidationError(`[turbine] Cannot disconnect "${relName}": foreign key column(s) ${fks.join(', ')} are NOT NULL. Use delete instead.`);
+                    throw new errors_js_1.ValidationError(`Cannot disconnect "${relName}": foreign key column(s) ${fks.join(', ')} are NOT NULL. Use delete instead.`);
                 }
                 const updateData = {};
                 for (const fk of fks) {
@@ -1033,7 +1033,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 errors_js_1.ValidationError(`[turbine] connect on "${relName}": no ${rel.to} row found matching ${(0, errors_js_1.describeTargetForMessage)(target)}.`);
+                throw new errors_js_1.ValidationError(`connect on "${relName}": no ${rel.to} row found matching ${(0, errors_js_1.describeTargetForMessage)(target)}.`);
             }
         }
     }
@@ -1088,7 +1088,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 errors_js_1.ValidationError(`[turbine] connect on "${relName}": no ${rel.to} row found matching ${(0, errors_js_1.describeTargetForMessage)(target)}.`);
+                throw new errors_js_1.ValidationError(`connect on "${relName}": no ${rel.to} row found matching ${(0, errors_js_1.describeTargetForMessage)(target)}.`);
             }
             const updateData = {};
             const relatedTable = ctx.schema.tables[rel.to];
@@ -1138,7 +1138,7 @@ function assertConnectInScope(ctx, rel, child, parentRow, target) {
             continue;
         if (current === key(parentRow[refField]))
             continue;
-        throw new errors_js_1.ValidationError(`[turbine] connect refused: ${rel.to} row ${(0, errors_js_1.describeTargetForMessage)(target)} is already owned by ` +
+        throw new errors_js_1.ValidationError(`connect refused: ${rel.to} row ${(0, errors_js_1.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.`);
     }
@@ -1153,7 +1153,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 errors_js_1.ValidationError(`[turbine] connect: no ${rel.to} row found matching ${(0, errors_js_1.describeTargetForMessage)(target)}.`);
+            throw new errors_js_1.ValidationError(`connect: no ${rel.to} row found matching ${(0, errors_js_1.describeTargetForMessage)(target)}.`);
         }
         assertConnectInScope(ctx, rel, existing, parentRow, target);
     }
@@ -1205,7 +1205,7 @@ async function processDisconnect(ctx, rel, disconnectArg, relName, parentRow) {
         return col?.nullable ?? false;
     });
     if (!nullable) {
-        throw new errors_js_1.ValidationError(`[turbine] Cannot disconnect "${relName}": foreign key column(s) ${fks.join(', ')} on "${rel.to}" are NOT NULL. Use delete instead.`);
+        throw new errors_js_1.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)
@@ -1248,7 +1248,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 errors_js_1.ValidationError(`[turbine] Nested set on relation "${rel.name}" cannot run: the parent's reference key ` +
+            throw new errors_js_1.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.`);
         }
@@ -1286,7 +1286,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 errors_js_1.ValidationError(`[turbine] Nested update on "${rel.name}" requires both "where" and "data" fields.`);
+            throw new errors_js_1.ValidationError(`Nested update on "${rel.name}" requires both "where" and "data" fields.`);
         }
         assertTargetSelectsSomething(item.where, 'update', relName, rel);
         if (!correlation)
@@ -1310,7 +1310,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 errors_js_1.ValidationError(`[turbine] Nested upsert on "${rel.name}" requires "where", "create", and "update" fields.`);
+            throw new errors_js_1.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;
@@ -1332,7 +1332,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 errors_js_1.ValidationError(`[turbine] Nested update on belongsTo "${rel.name}" requires a "data" field.`);
+        throw new errors_js_1.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
@@ -1354,7 +1354,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 errors_js_1.ValidationError(`[turbine] Nested upsert on belongsTo "${rel.name}" requires "where", "create", and "update" fields.`);
+        throw new errors_js_1.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/cjs/observe.js

@@ -164,7 +164,7 @@ class ObserveEngine {
     stopped = false;
     constructor(config) {
         if (!config.sink && !config.connectionString) {
-            throw new errors_js_1.ValidationError('[turbine] ObserveEngine: neither `connectionString` nor `sink` was provided, so there is nowhere to ' +
+            throw new errors_js_1.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/cjs/pipeline-submittable.js

@@ -318,7 +318,11 @@ 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 errors_js_1.TimeoutError(timeout, 'Pipeline');
                 if (connection.stream.destroy) {
                     connection.stream.destroy(pipelineError);
                 }

package/dist/cjs/pipeline.js

@@ -222,6 +222,14 @@ 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 errors_js_1.TurbineError)
+            throw err;
+        throw (0, errors_js_1.wrapPgError)(err);
+    }
     finally {
         client.release();
     }

package/dist/cjs/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/cjs/powdb-introspect.js

@@ -67,7 +67,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.introspectPowdbDatabase = introspectPowdbDatabase;
 const errors_js_1 = require("./errors.js");
 const introspect_js_1 = require("./introspect.js");
-const powdb_js_1 = require("./powdb.js");
+const powdb_shared_js_1 = require("./powdb-shared.js");
 const schema_js_1 = require("./schema.js");
 /** Coerce a wire cell to string (legacy wire cells are strings; native cells may be typed). */
 function asString(v) {
@@ -116,7 +116,7 @@ async function introspectPowdbDatabase(exec, options = {}) {
     // knows the version, so a pre-0.10 engine gets a typed E017 hint instead of
     // an opaque `unexpected token schema` parse error.
     if (options.capabilities) {
-        (0, powdb_js_1.requireCapability)(options.capabilities, 'introspection', 'PowDB `describe` introspection');
+        (0, powdb_shared_js_1.requireCapability)(options.capabilities, 'introspection', 'PowDB `describe` introspection');
     }
     // ----- Types (one row per table, columns `name`, `columns`) -----
     const schemaRows = (await exec('schema')).rows;
@@ -126,7 +126,7 @@ 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 errors_js_1.ValidationError(`[turbine] PowDB introspection: the \`schema\` statement returned ${schemaRows.length} row(s) but none carried a ` +
+        throw new errors_js_1.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).');
     }
@@ -137,7 +137,7 @@ async function introspectPowdbDatabase(exec, options = {}) {
         // `describe` needs the table name in bare-identifier position → quote it so
         // a reserved-word / non-bare table name (`order`) does not become a parse
         // error.
-        const describeRows = (await exec(`describe ${(0, powdb_js_1.quotePowqlIdent)(tableName)}`)).rows
+        const describeRows = (await exec(`describe ${(0, powdb_shared_js_1.quotePowqlIdent)(tableName)}`)).rows
             // PowDB >= 0.19.1 appends entity-LINK rows after the 4 column rows in
             // `describe <T>` (a `type` cell of literally `"link"`, an Empty nullable
             // slot, and an arrow description in the index slot). They are NOT columns,