turbine-orm 0.5.0 → 0.7.0

package/dist/cjs/errors.js

@@ -0,0 +1,293 @@
+"use strict";
+/**
+ * turbine-orm — Error types
+ *
+ * Typed errors with error codes for programmatic handling.
+ * All Turbine errors extend TurbineError which includes a `code` property.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckConstraintError = exports.NotNullViolationError = exports.ForeignKeyError = exports.UniqueConstraintError = exports.CircularRelationError = exports.MigrationError = exports.RelationError = exports.ConnectionError = exports.ValidationError = exports.TimeoutError = exports.NotFoundError = exports.TurbineError = exports.TurbineErrorCode = void 0;
+exports.wrapPgError = wrapPgError;
+/** Error codes for all Turbine errors */
+exports.TurbineErrorCode = {
+    NOT_FOUND: 'TURBINE_E001',
+    TIMEOUT: 'TURBINE_E002',
+    VALIDATION: 'TURBINE_E003',
+    CONNECTION: 'TURBINE_E004',
+    RELATION: 'TURBINE_E005',
+    MIGRATION: 'TURBINE_E006',
+    CIRCULAR_RELATION: 'TURBINE_E007',
+    UNIQUE_VIOLATION: 'TURBINE_E008',
+    FOREIGN_KEY_VIOLATION: 'TURBINE_E009',
+    NOT_NULL_VIOLATION: 'TURBINE_E010',
+    CHECK_VIOLATION: 'TURBINE_E011',
+};
+/** Base error class for all Turbine errors */
+class TurbineError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.name = 'TurbineError';
+        this.code = code;
+    }
+}
+exports.TurbineError = TurbineError;
+/**
+ * Thrown when a record is not found (findUniqueOrThrow, findFirstOrThrow,
+ * update/delete against a non-matching row, etc.)
+ *
+ * Supports two call styles for back-compat:
+ *   - `new NotFoundError()` / `new NotFoundError('custom message')`
+ *   - `new NotFoundError({ table, where, operation, cause, message })`
+ *
+ * When called with an options object and no explicit `message`, a Prisma-style
+ * message is built automatically, e.g.:
+ *   `[turbine] findUniqueOrThrow on "users" found no record matching where: {"id":1}`
+ */
+class NotFoundError extends TurbineError {
+    table;
+    where;
+    operation;
+    constructor(input) {
+        // Back-compat: string argument (or undefined) — replicate legacy behavior.
+        if (typeof input === 'string' || input === undefined) {
+            super(exports.TurbineErrorCode.NOT_FOUND, input ?? 'Record not found');
+            this.name = 'NotFoundError';
+            return;
+        }
+        const { table, where, operation, cause } = input;
+        let message = input.message;
+        if (!message) {
+            if (operation && table) {
+                const wherePart = where !== undefined ? ` matching where: ${JSON.stringify(where)}` : '';
+                message = `[turbine] ${operation} on "${table}" found no record${wherePart}`;
+            }
+            else if (table) {
+                const wherePart = where !== undefined ? ` matching where ${JSON.stringify(where)}` : '';
+                message = `[turbine] No record found in "${table}"${wherePart}`;
+            }
+            else {
+                message = '[turbine] Record not found';
+            }
+        }
+        super(exports.TurbineErrorCode.NOT_FOUND, message, { cause });
+        this.name = 'NotFoundError';
+        this.table = table;
+        this.where = where;
+        this.operation = operation;
+    }
+}
+exports.NotFoundError = NotFoundError;
+/** Thrown when a query or transaction exceeds the configured timeout */
+class TimeoutError extends TurbineError {
+    timeoutMs;
+    constructor(timeoutMs, context = 'Query') {
+        super(exports.TurbineErrorCode.TIMEOUT, `[turbine] ${context} timed out after ${timeoutMs}ms`);
+        this.name = 'TimeoutError';
+        this.timeoutMs = timeoutMs;
+    }
+}
+exports.TimeoutError = TimeoutError;
+/** Thrown when query arguments fail validation (unknown column, invalid operator, etc.) */
+class ValidationError extends TurbineError {
+    constructor(message) {
+        super(exports.TurbineErrorCode.VALIDATION, message);
+        this.name = 'ValidationError';
+    }
+}
+exports.ValidationError = ValidationError;
+/** Thrown when a database connection fails */
+class ConnectionError extends TurbineError {
+    constructor(message) {
+        super(exports.TurbineErrorCode.CONNECTION, message);
+        this.name = 'ConnectionError';
+    }
+}
+exports.ConnectionError = ConnectionError;
+/** Thrown when a relation reference is invalid */
+class RelationError extends TurbineError {
+    constructor(message) {
+        super(exports.TurbineErrorCode.RELATION, message);
+        this.name = 'RelationError';
+    }
+}
+exports.RelationError = RelationError;
+/** Thrown when a migration operation fails */
+class MigrationError extends TurbineError {
+    constructor(message) {
+        super(exports.TurbineErrorCode.MIGRATION, message);
+        this.name = 'MigrationError';
+    }
+}
+exports.MigrationError = MigrationError;
+/** Thrown when circular relation nesting is detected */
+class CircularRelationError extends TurbineError {
+    path;
+    constructor(path) {
+        super(exports.TurbineErrorCode.CIRCULAR_RELATION, `[turbine] Circular or too-deep relation nesting detected: ${path.join(' → ')}. Maximum nesting depth is 10.`);
+        this.name = 'CircularRelationError';
+        this.path = path;
+    }
+}
+exports.CircularRelationError = CircularRelationError;
+// ---------------------------------------------------------------------------
+// Database constraint violation errors
+// ---------------------------------------------------------------------------
+/**
+ * Extract the `detail` string from a pg-style error stored as `cause`.
+ * Returns undefined if the cause is not an object or has no detail.
+ */
+function detailFromCause(cause) {
+    if (!cause || typeof cause !== 'object')
+        return undefined;
+    const d = cause.detail;
+    return typeof d === 'string' && d.length > 0 ? d : undefined;
+}
+/** Thrown when a UNIQUE constraint is violated (pg code 23505) */
+class UniqueConstraintError extends TurbineError {
+    constraint;
+    columns;
+    table;
+    constructor(opts = {}) {
+        const { constraint, columns, table, cause } = opts;
+        let message = opts.message;
+        if (!message) {
+            const constraintPart = constraint ? ` on ${constraint}` : '';
+            const columnsPart = columns && columns.length > 0 ? ` (${columns.join(', ')})` : '';
+            message = `[turbine] Unique constraint violation${constraintPart}${columnsPart}`;
+            const detail = detailFromCause(cause);
+            if (detail)
+                message += `: ${detail}`;
+        }
+        super(exports.TurbineErrorCode.UNIQUE_VIOLATION, message, { cause });
+        this.name = 'UniqueConstraintError';
+        this.constraint = constraint;
+        this.columns = columns;
+        this.table = table;
+    }
+}
+exports.UniqueConstraintError = UniqueConstraintError;
+/** Thrown when a FOREIGN KEY constraint is violated (pg code 23503) */
+class ForeignKeyError extends TurbineError {
+    constraint;
+    table;
+    constructor(opts = {}) {
+        const { constraint, table, cause } = opts;
+        let message = opts.message;
+        if (!message) {
+            const constraintPart = constraint ? ` on ${constraint}` : '';
+            message = `[turbine] Foreign key constraint violation${constraintPart}`;
+            const detail = detailFromCause(cause);
+            if (detail)
+                message += `: ${detail}`;
+        }
+        super(exports.TurbineErrorCode.FOREIGN_KEY_VIOLATION, message, { cause });
+        this.name = 'ForeignKeyError';
+        this.constraint = constraint;
+        this.table = table;
+    }
+}
+exports.ForeignKeyError = ForeignKeyError;
+/** Thrown when a NOT NULL constraint is violated (pg code 23502) */
+class NotNullViolationError extends TurbineError {
+    column;
+    table;
+    constructor(opts = {}) {
+        const { column, table, cause } = opts;
+        let message = opts.message;
+        if (!message) {
+            const columnPart = column ? ` on column "${column}"` : '';
+            message = `[turbine] NOT NULL constraint violation${columnPart}`;
+            const detail = detailFromCause(cause);
+            if (detail)
+                message += `: ${detail}`;
+        }
+        super(exports.TurbineErrorCode.NOT_NULL_VIOLATION, message, { cause });
+        this.name = 'NotNullViolationError';
+        this.column = column;
+        this.table = table;
+    }
+}
+exports.NotNullViolationError = NotNullViolationError;
+/** Thrown when a CHECK constraint is violated (pg code 23514) */
+class CheckConstraintError extends TurbineError {
+    constraint;
+    table;
+    constructor(opts = {}) {
+        const { constraint, table, cause } = opts;
+        let message = opts.message;
+        if (!message) {
+            const constraintPart = constraint ? ` on ${constraint}` : '';
+            message = `[turbine] Check constraint violation${constraintPart}`;
+            const detail = detailFromCause(cause);
+            if (detail)
+                message += `: ${detail}`;
+        }
+        super(exports.TurbineErrorCode.CHECK_VIOLATION, message, { cause });
+        this.name = 'CheckConstraintError';
+        this.constraint = constraint;
+        this.table = table;
+    }
+}
+exports.CheckConstraintError = CheckConstraintError;
+/**
+ * Parse column names out of a pg `detail` string like:
+ *   "Key (email)=(foo@bar) already exists."
+ *   "Key (col1, col2)=(v1, v2) already exists."
+ */
+function parseColumnsFromDetail(detail) {
+    const m = detail.match(/^Key \(([^)]+)\)/);
+    if (!m)
+        return undefined;
+    return m[1].split(',').map((s) => s.trim());
+}
+/**
+ * Translate a pg driver error into a typed Turbine error.
+ * If the error doesn't match a known constraint code, returns it unchanged.
+ *
+ * Maps:
+ *   23505 (unique_violation)      -> UniqueConstraintError
+ *   23503 (foreign_key_violation) -> ForeignKeyError
+ *   23502 (not_null_violation)    -> NotNullViolationError
+ *   23514 (check_violation)       -> CheckConstraintError
+ *
+ * The original pg error is preserved as `.cause` on the wrapped error.
+ */
+function wrapPgError(err) {
+    if (!err || typeof err !== 'object')
+        return err;
+    const e = err;
+    if (!e.code)
+        return err;
+    switch (e.code) {
+        case '23505': {
+            const cols = e.detail ? parseColumnsFromDetail(e.detail) : undefined;
+            return new UniqueConstraintError({
+                constraint: e.constraint,
+                columns: cols,
+                table: e.table,
+                cause: err,
+            });
+        }
+        case '23503':
+            return new ForeignKeyError({
+                constraint: e.constraint,
+                table: e.table,
+                cause: err,
+            });
+        case '23502':
+            return new NotNullViolationError({
+                column: e.column,
+                table: e.table,
+                cause: err,
+            });
+        case '23514':
+            return new CheckConstraintError({
+                constraint: e.constraint,
+                table: e.table,
+                cause: err,
+            });
+        default:
+            return err;
+    }
+}

package/dist/cjs/generate.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * @batadata/turbine — Code generator
+ * turbine-orm — Code generator
  *
  * Takes an IntrospectedSchema and emits TypeScript files:
  *   - types.ts     — Entity interfaces, Create/Update input types
@@ -55,18 +55,16 @@ function generate(options) {
 function generatedFileHeader() {
     return [
         '/**',
-        ' * Auto-generated by @batadata/turbine — DO NOT EDIT',
+        ' * Auto-generated by turbine-orm — DO NOT EDIT',
         ' *',
         ` * Generated at: ${new Date().toISOString()}`,
-        ' * @see https://batadata.com/docs/turbine',
+        ' * @see https://turbineorm.dev',
         ' */',
         '',
     ];
 }
 function generateTypes(schema) {
-    const lines = [
-        ...generatedFileHeader(),
-    ];
+    const lines = [...generatedFileHeader()];
     // Generate enum types
     for (const [enumName, labels] of Object.entries(schema.enums)) {
         const typeName = (0, schema_js_1.snakeToPascal)(enumName);
@@ -116,9 +114,23 @@ function generateTypes(schema) {
         }
         lines.push('};');
         lines.push('');
-        // --- Relation types ---
+        // --- Relations map (for type-safe `with` clauses) ---
         const hasRelations = Object.keys(table.relations).length > 0;
         if (hasRelations) {
+            lines.push(`/** Available relations for the \`${table.name}\` table */`);
+            lines.push(`export interface ${typeName}Relations {`);
+            for (const [relName, rel] of Object.entries(table.relations)) {
+                const targetType = entityName(rel.to);
+                if (rel.type === 'hasMany') {
+                    lines.push(`  ${relName}: ${targetType}[];`);
+                }
+                else {
+                    lines.push(`  ${relName}: ${targetType} | null;`);
+                }
+            }
+            lines.push('}');
+            lines.push('');
+            // --- Legacy per-relation interfaces (kept for backward compatibility) ---
             for (const [relName, rel] of Object.entries(table.relations)) {
                 const targetType = entityName(rel.to);
                 if (rel.type === 'hasMany') {
@@ -145,7 +157,7 @@ function generateTypes(schema) {
 function generateMetadata(schema) {
     const lines = [
         ...generatedFileHeader(),
-        "import type { SchemaMetadata } from '@batadata/turbine';",
+        "import type { SchemaMetadata } from 'turbine-orm';",
         '',
         'export const SCHEMA: SchemaMetadata = {',
         '  tables: {',
@@ -218,12 +230,18 @@ function generateIndex(schema) {
     const tableEntries = Object.values(schema.tables);
     const lines = [
         ...generatedFileHeader(),
-        "import { TurbineClient as BaseTurbineClient, QueryInterface } from '@batadata/turbine';",
-        "import type { TurbineConfig } from '@batadata/turbine';",
+        "import { TurbineClient as BaseTurbineClient, QueryInterface } from 'turbine-orm';",
+        "import type { TurbineConfig } from 'turbine-orm';",
         "import { SCHEMA } from './metadata.js';",
     ];
-    // Import all entity types
-    const typeImports = tableEntries.map((t) => entityName(t.name));
+    // Import all entity types and relations maps
+    const typeImports = [];
+    for (const t of tableEntries) {
+        typeImports.push(entityName(t.name));
+        if (Object.keys(t.relations).length > 0) {
+            typeImports.push(`${entityName(t.name)}Relations`);
+        }
+    }
     lines.push(`import type { ${typeImports.join(', ')} } from './types.js';`);
     lines.push('');
     // Generate the client class with JSDoc
@@ -249,8 +267,10 @@ function generateIndex(schema) {
     for (const table of tableEntries) {
         const typeName = entityName(table.name);
         const accessor = snakeToCamelStr(table.name);
+        const hasRelations = Object.keys(table.relations).length > 0;
+        const genericArgs = hasRelations ? `${typeName}, ${typeName}Relations` : typeName;
         lines.push(`  /** Query interface for the \`${table.name}\` table */`);
-        lines.push(`  declare readonly ${accessor}: QueryInterface<${typeName}>;`);
+        lines.push(`  declare readonly ${accessor}: QueryInterface<${genericArgs}>;`);
     }
     lines.push('');
     lines.push('  constructor(config?: TurbineConfig) {');

package/dist/cjs/index.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * @batadata/turbine
+ * turbine-orm
  *
  * Turbine TypeScript SDK — type-safe Postgres queries with nested relations
  * and pipeline batching. Feels like Prisma, runs at raw-SQL speed.
@@ -34,42 +34,61 @@
  * ```
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.schemaPush = exports.schemaDiff = exports.schemaToSQLString = exports.schemaToSQL = exports.ColumnBuilder = exports.column = exports.table = exports.defineSchema = exports.generate = exports.introspect = exports.pgArrayType = exports.isDateType = exports.pgTypeToTs = exports.singularize = exports.snakeToPascal = exports.camelToSnake = exports.snakeToCamel = exports.executePipeline = exports.QueryInterface = exports.TransactionClient = exports.TurbineClient = void 0;
+exports.turbineHttp = exports.schemaToSQLString = exports.schemaToSQL = exports.schemaPush = exports.schemaDiff = exports.table = exports.defineSchema = exports.column = exports.ColumnBuilder = exports.snakeToPascal = exports.snakeToCamel = exports.singularize = exports.pgTypeToTs = exports.pgArrayType = exports.isDateType = exports.camelToSnake = exports.QueryInterface = exports.executePipeline = exports.introspect = exports.generate = exports.wrapPgError = exports.ValidationError = exports.UniqueConstraintError = exports.TurbineErrorCode = exports.TurbineError = exports.TimeoutError = exports.RelationError = exports.NotNullViolationError = exports.NotFoundError = exports.MigrationError = exports.ForeignKeyError = exports.ConnectionError = exports.CircularRelationError = exports.CheckConstraintError = exports.TurbineClient = exports.TransactionClient = void 0;
 // Client
 var client_js_1 = require("./client.js");
-Object.defineProperty(exports, "TurbineClient", { enumerable: true, get: function () { return client_js_1.TurbineClient; } });
 Object.defineProperty(exports, "TransactionClient", { enumerable: true, get: function () { return client_js_1.TransactionClient; } });
-// Query builder
-var query_js_1 = require("./query.js");
-Object.defineProperty(exports, "QueryInterface", { enumerable: true, get: function () { return query_js_1.QueryInterface; } });
+Object.defineProperty(exports, "TurbineClient", { enumerable: true, get: function () { return client_js_1.TurbineClient; } });
+// Error types
+var errors_js_1 = require("./errors.js");
+Object.defineProperty(exports, "CheckConstraintError", { enumerable: true, get: function () { return errors_js_1.CheckConstraintError; } });
+Object.defineProperty(exports, "CircularRelationError", { enumerable: true, get: function () { return errors_js_1.CircularRelationError; } });
+Object.defineProperty(exports, "ConnectionError", { enumerable: true, get: function () { return errors_js_1.ConnectionError; } });
+Object.defineProperty(exports, "ForeignKeyError", { enumerable: true, get: function () { return errors_js_1.ForeignKeyError; } });
+Object.defineProperty(exports, "MigrationError", { enumerable: true, get: function () { return errors_js_1.MigrationError; } });
+Object.defineProperty(exports, "NotFoundError", { enumerable: true, get: function () { return errors_js_1.NotFoundError; } });
+Object.defineProperty(exports, "NotNullViolationError", { enumerable: true, get: function () { return errors_js_1.NotNullViolationError; } });
+Object.defineProperty(exports, "RelationError", { enumerable: true, get: function () { return errors_js_1.RelationError; } });
+Object.defineProperty(exports, "TimeoutError", { enumerable: true, get: function () { return errors_js_1.TimeoutError; } });
+Object.defineProperty(exports, "TurbineError", { enumerable: true, get: function () { return errors_js_1.TurbineError; } });
+Object.defineProperty(exports, "TurbineErrorCode", { enumerable: true, get: function () { return errors_js_1.TurbineErrorCode; } });
+Object.defineProperty(exports, "UniqueConstraintError", { enumerable: true, get: function () { return errors_js_1.UniqueConstraintError; } });
+Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function () { return errors_js_1.ValidationError; } });
+Object.defineProperty(exports, "wrapPgError", { enumerable: true, get: function () { return errors_js_1.wrapPgError; } });
+// Code generation
+var generate_js_1 = require("./generate.js");
+Object.defineProperty(exports, "generate", { enumerable: true, get: function () { return generate_js_1.generate; } });
+// Introspection
+var introspect_js_1 = require("./introspect.js");
+Object.defineProperty(exports, "introspect", { enumerable: true, get: function () { return introspect_js_1.introspect; } });
 // Pipeline
 var pipeline_js_1 = require("./pipeline.js");
 Object.defineProperty(exports, "executePipeline", { enumerable: true, get: function () { return pipeline_js_1.executePipeline; } });
+// Query builder
+var query_js_1 = require("./query.js");
+Object.defineProperty(exports, "QueryInterface", { enumerable: true, get: function () { return query_js_1.QueryInterface; } });
 // Schema utilities
 var schema_js_1 = require("./schema.js");
-Object.defineProperty(exports, "snakeToCamel", { enumerable: true, get: function () { return schema_js_1.snakeToCamel; } });
 Object.defineProperty(exports, "camelToSnake", { enumerable: true, get: function () { return schema_js_1.camelToSnake; } });
-Object.defineProperty(exports, "snakeToPascal", { enumerable: true, get: function () { return schema_js_1.snakeToPascal; } });
-Object.defineProperty(exports, "singularize", { enumerable: true, get: function () { return schema_js_1.singularize; } });
-Object.defineProperty(exports, "pgTypeToTs", { enumerable: true, get: function () { return schema_js_1.pgTypeToTs; } });
 Object.defineProperty(exports, "isDateType", { enumerable: true, get: function () { return schema_js_1.isDateType; } });
 Object.defineProperty(exports, "pgArrayType", { enumerable: true, get: function () { return schema_js_1.pgArrayType; } });
-// Introspection
-var introspect_js_1 = require("./introspect.js");
-Object.defineProperty(exports, "introspect", { enumerable: true, get: function () { return introspect_js_1.introspect; } });
-// Code generation
-var generate_js_1 = require("./generate.js");
-Object.defineProperty(exports, "generate", { enumerable: true, get: function () { return generate_js_1.generate; } });
+Object.defineProperty(exports, "pgTypeToTs", { enumerable: true, get: function () { return schema_js_1.pgTypeToTs; } });
+Object.defineProperty(exports, "singularize", { enumerable: true, get: function () { return schema_js_1.singularize; } });
+Object.defineProperty(exports, "snakeToCamel", { enumerable: true, get: function () { return schema_js_1.snakeToCamel; } });
+Object.defineProperty(exports, "snakeToPascal", { enumerable: true, get: function () { return schema_js_1.snakeToPascal; } });
 // Schema builder — define schemas in TypeScript
 var schema_builder_js_1 = require("./schema-builder.js");
+Object.defineProperty(exports, "ColumnBuilder", { enumerable: true, get: function () { return schema_builder_js_1.ColumnBuilder; } });
+Object.defineProperty(exports, "column", { enumerable: true, get: function () { return schema_builder_js_1.column; } });
 Object.defineProperty(exports, "defineSchema", { enumerable: true, get: function () { return schema_builder_js_1.defineSchema; } });
 // Legacy compat (deprecated — use object format with defineSchema)
 Object.defineProperty(exports, "table", { enumerable: true, get: function () { return schema_builder_js_1.table; } });
-Object.defineProperty(exports, "column", { enumerable: true, get: function () { return schema_builder_js_1.column; } });
-Object.defineProperty(exports, "ColumnBuilder", { enumerable: true, get: function () { return schema_builder_js_1.ColumnBuilder; } });
 // Schema SQL — generate DDL, diff, and push
 var schema_sql_js_1 = require("./schema-sql.js");
-Object.defineProperty(exports, "schemaToSQL", { enumerable: true, get: function () { return schema_sql_js_1.schemaToSQL; } });
-Object.defineProperty(exports, "schemaToSQLString", { enumerable: true, get: function () { return schema_sql_js_1.schemaToSQLString; } });
 Object.defineProperty(exports, "schemaDiff", { enumerable: true, get: function () { return schema_sql_js_1.schemaDiff; } });
 Object.defineProperty(exports, "schemaPush", { enumerable: true, get: function () { return schema_sql_js_1.schemaPush; } });
+Object.defineProperty(exports, "schemaToSQL", { enumerable: true, get: function () { return schema_sql_js_1.schemaToSQL; } });
+Object.defineProperty(exports, "schemaToSQLString", { enumerable: true, get: function () { return schema_sql_js_1.schemaToSQLString; } });
+// Serverless / edge factory
+var serverless_js_1 = require("./serverless.js");
+Object.defineProperty(exports, "turbineHttp", { enumerable: true, get: function () { return serverless_js_1.turbineHttp; } });

package/dist/cjs/introspect.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * @batadata/turbine — Schema introspection
+ * turbine-orm — Schema introspection
  *
  * Connects to a live Postgres database, reads information_schema + pg_catalog,
  * and produces a SchemaMetadata object describing every table, column, relation,
@@ -105,7 +105,7 @@ async function introspect(options) {
     });
     try {
         // Run all information_schema queries in parallel
-        const [tablesResult, columnsResult, pkResult, fkResult, uniqueResult, indexResult, enumResult,] = await Promise.all([
+        const [tablesResult, columnsResult, pkResult, fkResult, uniqueResult, indexResult, enumResult] = await Promise.all([
             pool.query(SQL_TABLES, [schema]),
             pool.query(SQL_COLUMNS, [schema]),
             pool.query(SQL_PRIMARY_KEYS, [schema]),
@@ -178,9 +178,7 @@ async function introspect(options) {
             const isUnique = row.indexdef.includes('UNIQUE');
             // Extract column names from indexdef (e.g. "CREATE INDEX idx ON tbl USING btree (col1, col2)")
             const colMatch = row.indexdef.match(/\((.+)\)/);
-            const columns = colMatch
-                ? colMatch[1].split(',').map((c) => c.trim().replace(/ (ASC|DESC)/i, ''))
-                : [];
+            const columns = colMatch ? colMatch[1].split(',').map((c) => c.trim().replace(/ (ASC|DESC)/i, '')) : [];
             indexesByTable.get(row.tablename).push({
                 name: row.indexname,
                 columns,

package/dist/cjs/pipeline.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * @batadata/turbine — Pipeline execution
+ * turbine-orm — Pipeline execution
  *
  * Pipelines batch multiple independent queries into a single database round-trip.
  * Instead of N sequential awaits (N round-trips), you get 1 round-trip for all N queries.
@@ -18,6 +18,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executePipeline = executePipeline;
+const errors_js_1 = require("./errors.js");
 // ---------------------------------------------------------------------------
 // Pipeline executor
 // ---------------------------------------------------------------------------
@@ -55,7 +56,13 @@ async function executePipeline(pool, queries) {
         // Future: use actual Postgres pipeline protocol for true pipelining.
         const results = [];
         for (const q of queries) {
-            const raw = await client.query(q.sql, q.params);
+            let raw;
+            try {
+                raw = await client.query(q.sql, q.params);
+            }
+            catch (err) {
+                throw (0, errors_js_1.wrapPgError)(err);
+            }
             results.push(q.transform(raw));
         }
         await client.query('COMMIT');