@dbcube/query-builder 5.2.2 → 5.2.3

package/dist/index.d.ts

@@ -1,5 +1,54 @@
 import { QueryEngine } from '@dbcube/core';
 
+export interface JoinCondition {
+	column1: string;
+	operator: string;
+	column2: string;
+}
+export interface Join {
+	type: "INNER" | "LEFT" | "RIGHT";
+	table: string;
+	on: JoinCondition;
+}
+export interface WhereCondition {
+	column: string;
+	operator: string;
+	value?: any;
+	type: "AND" | "OR";
+	isGroup: boolean;
+}
+export interface GroupedWhereCondition {
+	type: "AND" | "OR";
+	isGroup: true;
+	conditions: WhereCondition[];
+}
+export interface OrderBy {
+	column: string;
+	direction: "ASC" | "DESC";
+}
+export interface Aggregation {
+	type: "COUNT" | "SUM" | "AVG" | "MAX" | "MIN";
+	column: string;
+	alias: string;
+}
+export interface DML {
+	type: "select" | "insert" | "update" | "delete" | "columns";
+	database: string;
+	table: string;
+	columns: string[];
+	requestedFields?: string[];
+	computedFieldsNeeded?: any[];
+	distinct: boolean;
+	joins: Join[];
+	where: (WhereCondition | GroupedWhereCondition)[];
+	orderBy: OrderBy[];
+	groupBy: string[];
+	limit: number | null;
+	offset: number | null;
+	data: any[] | Record<string, any> | null;
+	aggregation: Aggregation | null;
+	having?: (WhereCondition | GroupedWhereCondition)[];
+}
 export interface PaginatedResult<T = DatabaseRecord> {
 	items: T[];
 	page: number;
@@ -80,6 +129,24 @@ export declare class Database {
 	 * });
 	 */
 	transaction<T>(callback: (trx: Database) => Promise<T>): Promise<T>;
+	/**
+	 * 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);
+	 * });
+	 */
+	batch(builder: (b: Database) => void): Promise<MutationInfo[][]>;
 	useComputes(): Promise<Database>;
 	useTriggers(): Promise<Database>;
 	connect(): Promise<void>;
@@ -143,6 +210,9 @@ export declare class Table<T extends DatabaseRecord = DatabaseRecord> {
 	private relations;
 	/** Builders de grupo mutan en sitio (ver clone()) */
 	private _mutable;
+	/** 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: DML[] | null;
 	private instance;
 	constructor(instance: Database, databaseName: string, tableName: string, engine: QueryEngine, computedFields?: ComputedFieldConfig[], triggers?: TriggerConfig[], txId?: string | null);
 	/**

package/dist/index.js

@@ -120,6 +120,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 ComputedFieldProcessor.getComputedFields(this.name);
@@ -185,7 +218,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;
@@ -205,13 +241,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 = {
@@ -838,6 +877,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;
@@ -864,13 +927,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");
@@ -889,13 +965,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");
@@ -910,10 +999,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;
@@ -1066,12 +1168,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();
   }
   /**
@@ -1271,8 +1387,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++) {
@@ -1332,6 +1448,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;