@dbcube/query-builder 5.2.2 → 5.2.3

package/dist/index.cjs

@@ -158,6 +158,39 @@ var Database = class _Database {
       throw error;
     }
   }
+  /**
+   * Atomic batch: every write queued in the callback runs inside ONE
+   * transaction with a SINGLE engine round-trip (begin/commit included).
+   * The callback is synchronous — writes are collected, not awaited.
+   * Any failure rolls back everything.
+   *
+   * This is the fastest way to run a sequence of writes atomically.
+   * For transactions that need to READ intermediate results, use
+   * `transaction()` (interactive) instead. Triggers/computed fields do
+   * not run in batch mode.
+   *
+   * @example
+   * await db.batch(b => {
+   *     b.table('accounts').where('id', '=', 1).decrement('balance', 200);
+   *     b.table('accounts').where('id', '=', 2).increment('balance', 200);
+   * });
+   */
+  async batch(builder) {
+    const ops = [];
+    const collector = new _Database(this.name);
+    collector.engine = this.engine;
+    collector.computedFields = this.computedFields;
+    collector.triggers = this.triggers;
+    collector._collectInto = ops;
+    builder(collector);
+    if (ops.length === 0) return [];
+    const response = await this.engine.executeBatch(ops);
+    if (response.status !== 200) {
+      returnFormattedError(response.status, response.message);
+      throw new Error(String(response.message));
+    }
+    return response.data;
+  }
   async useComputes() {
     const newDatabase = new _Database(this.name);
     const arrayComputedFields = await import_core2.ComputedFieldProcessor.getComputedFields(this.name);
@@ -223,7 +256,10 @@ var Database = class _Database {
    * const columns = await db.table('users').columns().get();
    */
   table(tableName) {
-    return new Table(this, this.name, tableName, this.engine, this.computedFields, this.triggers, this.txId);
+    const t = new Table(this, this.name, tableName, this.engine, this.computedFields, this.triggers, this.txId);
+    const sink = this._collectInto;
+    if (sink) t._batchSink = sink;
+    return t;
   }
   setComputedFields(computedFields) {
     this.computedFields = computedFields;
@@ -243,13 +279,16 @@ var Table = class _Table {
   relations = [];
   /** Builders de grupo mutan en sitio (ver clone()) */
   _mutable = false;
+  /** En modo batch (db.batch) las escrituras se encolan aquí en vez de
+   *  ejecutarse: toda la transacción viaja al engine en UN solo cruce. */
+  _batchSink = null;
   instance;
   constructor(instance, databaseName, tableName, engine, computedFields = [], triggers = [], txId = null) {
     this.engine = engine;
     this.instance = instance;
     this.computedFields = computedFields;
     this.triggers = triggers;
-    this.trigger = new Trigger(instance, databaseName, triggers);
+    this.trigger = triggers.length > 0 ? new Trigger(instance, databaseName, triggers) : null;
     this.nextType = "AND";
     this.txId = txId;
     this.dml = {
@@ -876,6 +915,30 @@ var Table = class _Table {
    * console.log(user); // { id: 1, name: 'John' }
    */
   async find(value, column = "id") {
+    if (this.computedFields.length === 0 && this.relations.length === 0 && !this._mutable) {
+      const dml = {
+        type: "select",
+        database: this.dml.database,
+        table: this.dml.table,
+        columns: ["*"],
+        distinct: false,
+        joins: [],
+        where: [{ column, operator: "=", value, type: "AND", isGroup: false }],
+        orderBy: [],
+        groupBy: [],
+        limit: 1,
+        offset: null,
+        data: null,
+        aggregation: null,
+        having: []
+      };
+      const response = await this.engine.executeDml(dml, this.txId ?? void 0);
+      if (response.status != 200) {
+        returnFormattedError(response.status, response.message);
+        throw new Error(String(response.message));
+      }
+      return response.data?.[0] || null;
+    }
     const clone = this.clone().where(column, "=", value);
     clone.dml.type = "select";
     clone.dml.data = null;
@@ -902,13 +965,26 @@ var Table = class _Table {
    * console.log(newUsers); // [{ id: 3, name: 'Alice', age: 28 }, { id: 4, name: 'Bob', age: 32 }]
    */
   async insert(data) {
-    const clone = this.clone();
     if (!Array.isArray(data)) {
       throw new Error("The insert method requires an array of objects with key-value pairs.");
     }
     if (!data.every((item) => typeof item === "object" && item !== null)) {
       throw new Error("The array must contain only valid objects.");
     }
+    if (this._batchSink) {
+      this._batchSink.push({ ...this.dml, type: "insert", data });
+      return void 0;
+    }
+    if (this.triggers.length === 0 && this.computedFields.length === 0) {
+      const dml = { ...this.dml, type: "insert", data };
+      const response = await this.engine.executeDml(dml, this.txId ?? void 0);
+      if (response.status != 200) {
+        returnFormattedError(response.status, response.message);
+        throw new Error(String(response.message));
+      }
+      return response.data ?? data;
+    }
+    const clone = this.clone();
     clone.dml.type = "insert";
     clone.dml.data = data;
     const result = await clone.getResponse(clone.dml, "Add");
@@ -927,13 +1003,26 @@ var Table = class _Table {
    * console.log(result); // { affectedRows: 1 }
    */
   async update(data) {
-    const clone = this.clone();
     if (typeof data !== "object" || Array.isArray(data)) {
       throw new Error("The update method requires an object with key-value pairs.");
     }
-    if (clone.dml.where.length === 0) {
+    if (this.dml.where.length === 0) {
       throw new Error("You must specify at least one WHERE condition to perform an update.");
     }
+    if (this._batchSink) {
+      this._batchSink.push({ ...this.dml, type: "update", data });
+      return void 0;
+    }
+    if (this.triggers.length === 0 && this.computedFields.length === 0) {
+      const dml = { ...this.dml, type: "update", data };
+      const response = await this.engine.executeDml(dml, this.txId ?? void 0);
+      if (response.status != 200) {
+        returnFormattedError(response.status, response.message);
+        throw new Error(String(response.message));
+      }
+      return response.data;
+    }
+    const clone = this.clone();
     clone.dml.type = "update";
     clone.dml.data = data;
     return clone.getResponse(clone.dml, "Update");
@@ -948,10 +1037,23 @@ var Table = class _Table {
    * console.log(result); // { affectedRows: 1 }
    */
   async delete() {
-    const clone = this.clone();
-    if (clone.dml.where.length === 0) {
+    if (this.dml.where.length === 0) {
       throw new Error("You must specify at least one WHERE condition to perform a delete.");
     }
+    if (this._batchSink) {
+      this._batchSink.push({ ...this.dml, type: "delete", data: null });
+      return void 0;
+    }
+    if (this.triggers.length === 0 && this.computedFields.length === 0) {
+      const dml = { ...this.dml, type: "delete", data: null };
+      const response = await this.engine.executeDml(dml, this.txId ?? void 0);
+      if (response.status != 200) {
+        returnFormattedError(response.status, response.message);
+        throw new Error(String(response.message));
+      }
+      return response.data;
+    }
+    const clone = this.clone();
     clone.dml.type = "delete";
     const deleteData = await clone.getResponse(clone.dml, "Delete");
     return deleteData;
@@ -1104,12 +1206,26 @@ var Table = class _Table {
    * await db.table('posts').where('id', '=', 1).increment('views', 1, { last_viewed_at: new Date().toISOString() });
    */
   async increment(column, amount = 1, extra = {}) {
-    const clone = this.clone();
-    if (clone.dml.where.length === 0) {
+    if (this.dml.where.length === 0) {
       throw new Error("You must specify at least one WHERE condition to perform an increment.");
     }
+    const data = { ...extra, [column]: { $inc: Number(amount) } };
+    if (this._batchSink) {
+      this._batchSink.push({ ...this.dml, type: "update", data });
+      return void 0;
+    }
+    if (this.triggers.length === 0 && this.computedFields.length === 0) {
+      const dml = { ...this.dml, type: "update", data };
+      const response = await this.engine.executeDml(dml, this.txId ?? void 0);
+      if (response.status != 200) {
+        returnFormattedError(response.status, response.message);
+        throw new Error(String(response.message));
+      }
+      return response.data;
+    }
+    const clone = this.clone();
     clone.dml.type = "update";
-    clone.dml.data = { ...extra, [column]: { $inc: Number(amount) } };
+    clone.dml.data = data;
     return clone.getResponse();
   }
   /**
@@ -1309,8 +1425,8 @@ var Table = class _Table {
     }
     let arrayResult = [];
     if (type) {
-      const beffore = this.trigger.get("before" + type);
-      const after = this.trigger.get("after" + type);
+      const beffore = this.trigger ? this.trigger.get("before" + type) : void 0;
+      const after = this.trigger ? this.trigger.get("after" + type) : void 0;
       if (this.triggers.length > 0 && (beffore || after)) {
         const dataset = localDML.data;
         for (let index = 0; index < dataset.length; index++) {
@@ -1370,6 +1486,7 @@ var Table = class _Table {
     const cloned = Object.create(Object.getPrototypeOf(this));
     cloned.engine = this.engine;
     cloned.instance = this.instance;
+    cloned._batchSink = this._batchSink;
     cloned.nextType = this.nextType;
     cloned.computedFields = this.computedFields;
     cloned.trigger = this.trigger;