turbine-orm 0.4.0 → 0.5.0

package/dist/cjs/pipeline.js

@@ -0,0 +1,71 @@
+"use strict";
+/**
+ * @batadata/turbine — 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.
+ *
+ * How it works:
+ *   1. Each query method (findUnique, count, etc.) can produce a DeferredQuery descriptor
+ *      containing the SQL, params, and a transform function.
+ *   2. pipeline() collects these descriptors, executes them in a single Postgres
+ *      pipeline/transaction, and maps each result through its transform.
+ *
+ * In the production Turbine engine, this would go through the Rust proxy which uses
+ * actual Postgres pipeline protocol (libpq PQpipelineEnter). For the TS SDK prototype,
+ * we simulate it by running queries concurrently on a single connection or via
+ * a multi-statement batch.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executePipeline = executePipeline;
+// ---------------------------------------------------------------------------
+// Pipeline executor
+// ---------------------------------------------------------------------------
+/**
+ * Execute multiple deferred queries in a single batch.
+ *
+ * Uses a single connection from the pool and runs all queries within
+ * a transaction to guarantee consistency and minimize round-trips.
+ *
+ * @example
+ * ```ts
+ * const [user, count, posts] = await executePipeline(pool, [
+ *   db.users.buildFindUnique({ where: { id: 1 } }),
+ *   db.posts.buildCount({ where: { orgId: 1 } }),
+ *   db.posts.buildFindMany({ where: { userId: 1 }, limit: 10 }),
+ * ]);
+ * ```
+ */
+async function executePipeline(pool, queries) {
+    if (queries.length === 0) {
+        return [];
+    }
+    // Acquire a single connection for the entire batch
+    const client = await pool.connect();
+    try {
+        // Wrap in a transaction for consistency
+        await client.query('BEGIN');
+        // Execute all queries on the same connection — in sequence on a single
+        // connection this avoids pool checkout overhead, and the Postgres server
+        // processes them as a tight batch.
+        //
+        // Execute queries sequentially on the same connection to avoid the
+        // "already executing a query" deprecation in pg@8. This is still faster
+        // than separate pool checkouts because we skip N-1 acquire/release cycles.
+        // 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);
+            results.push(q.transform(raw));
+        }
+        await client.query('COMMIT');
+        return results;
+    }
+    catch (err) {
+        await client.query('ROLLBACK');
+        throw err;
+    }
+    finally {
+        client.release();
+    }
+}