@dbcube/query-builder/dist/index.cjs

The Dbcube Query Builder is a lightweight, flexible, and fluent library for building queries across multiple database engines, including MySQL, PostgreSQL, SQLite, and MongoDB, using JavaScript/Node.js. Its agnostic design allows you to generate data man

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var index_exports = {};
__export(index_exports, {
  Database: () => Database,
  Table: () => Table,
  default: () => index_default
});
module.exports = __toCommonJS(index_exports);

// src/lib/Database.ts
var import_fs = __toESM(require("fs"));
var import_core2 = require("@dbcube/core");

// src/lib/Trigger.ts
var import_path = __toESM(require("path"));
var import_core = require("@dbcube/core");
var import_module = require("module");
var Trigger = class {
  triggers;
  databaseName;
  instance;
  constructor(instance, databaseName, metadata) {
    this.triggers = metadata;
    this.databaseName = databaseName;
    this.instance = instance;
  }
  get(type) {
    return this.triggers.find((tr) => tr.type === type);
  }
  async execute(type, row) {
    const trigger = this.triggers.find((tr) => tr.type === type);
    if (trigger) {
      const logFilePath = import_path.default.resolve(
        process.cwd(),
        "dbcube",
        "logs",
        "triggers",
        this.databaseName,
        `${trigger.table_ref}_${trigger.type}.log`
      );
      const interceptor = import_core.FileLogger.interceptConsole(logFilePath, {
        keepOriginal: false,
        useBuffer: true
      });
      const pathFile = import_path.default.resolve(process.cwd(), "dbcube", "triggers", `${trigger.database_ref}_${trigger.table_ref}_${trigger.type}.js`);
      const requireUrl = typeof __filename !== "undefined" ? __filename : process.cwd();
      const require2 = (0, import_module.createRequire)(requireUrl);
      delete require2.cache[require2.resolve(pathFile)];
      const triggerModule = require2(pathFile);
      const dataProcess = triggerModule.default || triggerModule;
      await dataProcess({ db: this.instance, oldData: row, newData: row });
      interceptor.restore();
      return interceptor;
    }
    return null;
  }
};

// src/lib/Database.ts
var Database = class _Database {
  name;
  engine;
  computedFields;
  triggers;
  constructor(name) {
    this.name = name;
    const engine = new import_core2.QueryEngine(name);
    this.engine = engine;
    this.computedFields = [];
    this.triggers = [];
  }
  async useComputes() {
    const newDatabase = new _Database(this.name);
    const arrayComputedFields = await import_core2.ComputedFieldProcessor.getComputedFields(this.name);
    newDatabase.setComputedFields(arrayComputedFields);
    return newDatabase;
  }
  async useTriggers() {
    const newDatabase = new _Database(this.name);
    const arrayTriggers = await import_core2.TriggerProcessor.getTriggers(this.name);
    newDatabase.setTriggers(arrayTriggers);
    return newDatabase;
  }
  async connect() {
    const response = await this.engine.run("query_engine", [
      "--action",
      "connect"
    ]);
    if (response.status != 200) {
      returnFormattedError(response.status, response.message);
    }
    return response.data;
  }
  async disconnect() {
    return this.engine.run("query_engine", [
      "--action",
      "disconnect"
    ]);
  }
  /**
   * Creates and returns a new instance of `Table` for the specified table.
   * This method is used to start building queries for a specific table.
   * It provides a fluent interface for common database operations like select, insert, update, and delete.
   *
   * @param {string} tableName - The name of the table to query.
   * @returns {Table} - Returns a new instance of `Table` for the specified table.
   *
   * @example
   * // Select all records from a table
   * const users = await db.table('users').get();
   * 
   * // Select records with conditions
   * const activeUsers = await db.table('users')
   *     .where('status', '=', 'active')
   *     .orderBy('created_at', 'DESC')
   *     .limit(10)
   *     .get();
   * 
   * // Insert records
   * await db.table('users').insert([
   *     { name: 'John', email: 'john@example.com', age: 30 }
   * ]);
   * 
   * // Update records
   * await db.table('users')
   *     .where('id', '=', 1)
   *     .update({ status: 'inactive' });
   * 
   * // Delete records
   * await db.table('users')
   *     .where('status', '=', 'deleted')
   *     .delete();
   * 
   * // Access column management
   * const columns = await db.table('users').columns().get();
   */
  table(tableName) {
    return new Table(this, this.name, tableName, this.engine, this.computedFields, this.triggers);
  }
  setComputedFields(computedFields) {
    this.computedFields = computedFields;
  }
  setTriggers(triggers) {
    this.triggers = triggers;
  }
};
var Table = class _Table {
  engine;
  nextType = "AND";
  dml;
  computedFields = [];
  trigger;
  triggers;
  constructor(instance, databaseName, tableName, engine = null, computedFields = [], triggers = []) {
    this.engine = engine;
    this.computedFields = computedFields;
    this.triggers = triggers;
    this.trigger = new Trigger(instance, databaseName, triggers);
    this.nextType = "AND";
    this.dml = {
      type: "select",
      database: databaseName,
      table: tableName,
      columns: ["*"],
      distinct: false,
      joins: [],
      where: [],
      orderBy: [],
      groupBy: [],
      limit: null,
      offset: null,
      data: null,
      aggregation: null
    };
  }
  /**
   * Specifies the columns to select in a SELECT query.
   *
   * @param {string[]} fields - Array of column names to select. If empty, selects all columns.
   * @returns {Table} - Returns the current instance of Table for method chaining.
   *
   * @example
   * const users = await db.table('users').select(['id', 'name']).get();
   * console.log(users); // [{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }]
   */
  select(fields = []) {
    const clone = this.clone();
    clone.dml.type = "select";
    clone.dml.columns = fields.length > 0 ? fields : ["*"];
    clone.dml.aggregation = null;
    return clone;
  }
  where(column, operator, value) {
    const clone = this.clone();
    clone.dml.where.push({
      column,
      operator,
      value,
      type: clone.nextType,
      isGroup: false
    });
    clone.nextType = "AND";
    return clone;
  }
  orWhere(column, operator, value) {
    const clone = this.clone();
    clone.dml.where.push({
      column,
      operator,
      value,
      type: "OR",
      isGroup: false
    });
    return clone;
  }
  /**
   * Adds a grouped WHERE condition to the query.
   *
   * @param {WhereCallback} callback - A callback function that receives a new Table instance to build the grouped conditions.
   * @returns {Table} - Returns the current instance of Table for method chaining.
   *
   * @example
   * const users = await db.table('users').whereGroup(query => {
   *     query.where('age', '>', 25).orWhere('name', '=', 'Jane');
   * }).get();
   * console.log(users); // [{ id: 1, name: 'John', age: 30 }, { id: 2, name: 'Jane', age: 25 }]
   */
  whereGroup(callback) {
    const clone = this.clone();
    const groupQuery = new _Table(this, clone.dml.database, clone.dml.table, clone.engine);
    callback(groupQuery);
    clone.dml.where.push({
      type: clone.nextType,
      isGroup: true,
      conditions: groupQuery.dml.where
    });
    clone.nextType = "AND";
    return clone;
  }
  or() {
    const clone = this.clone();
    clone.nextType = "OR";
    return clone;
  }
  and() {
    const clone = this.clone();
    clone.nextType = "AND";
    return clone;
  }
  /**
   * Adds a WHERE BETWEEN condition to the query.
   *
   * @param {string} column - The column to filter by.
   * @param {[any, any]} values - A tuple with two values representing the range.
   * @returns {Table} - Returns the current instance of Table for method chaining.
   *
   * @example
   * const users = await db.table('users').whereBetween('age', [20, 30]).get();
   * console.log(users); // [{ id: 1, name: 'John', age: 30 }, { id: 2, name: 'Jane', age: 25 }]
   */
  whereBetween(column, values) {
    const clone = this.clone();
    const [value1, value2] = values;
    if (value1 !== void 0 && value2 !== void 0) {
      clone.dml.where.push({
        column,
        operator: "BETWEEN",
        value: [value1, value2],
        type: clone.nextType,
        isGroup: false
      });
      clone.nextType = "AND";
    }
    return clone;
  }
  /**
   * Adds a WHERE IN condition to the query.
   *
   * @param {string} column - The column to filter by.
   * @param {any[]} values - An array of values to match.
   * @returns {Table} - Returns the current instance of Table for method chaining.
   *
   * @example
   * const users = await db.table('users').whereIn('id', [1, 2]).get();
   * console.log(users); // [{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }]
   */
  whereIn(column, values) {
    const clone = this.clone();
    if (Array.isArray(values) && values.length > 0) {
      clone.dml.where.push({
        column,
        operator: "IN",
        value: values,
        type: clone.nextType,
        isGroup: false
      });
      clone.nextType = "AND";
    }
    return clone;
  }
  /**
  * Adds a WHERE IS NULL condition to the query.
  *
  * @param {string} column - The column to filter by.
  * @returns {Table} - Returns the current instance of Table for method chaining.
  *
  * @example
  * const users = await db.table('users').whereNull('email').get();
  * console.log(users); // [{ id: 3, name: 'Alice', email: null }]
  */
  whereNull(column) {
    const clone = this.clone();
    clone.dml.where.push({
      column,
      operator: "IS NULL",
      type: clone.nextType,
      isGroup: false
    });
    clone.nextType = "AND";
    return clone;
  }
  /**
   * Adds a WHERE IS NOT NULL condition to the query.
   *
   * @param {string} column - The column to filter by.
   * @returns {Table} - Returns the current instance of Table for method chaining.
   *
   * @example
   * const users = await db.table('users').whereNotNull('email').get();
   * console.log(users); // [{ id: 1, name: 'John', email: 'john@example.com' }]
   */
  whereNotNull(column) {
    const clone = this.clone();
    clone.dml.where.push({
      column,
      operator: "IS NOT NULL",
      type: clone.nextType,
      isGroup: false
    });
    clone.nextType = "AND";
    return clone;
  }
  /**
   * Adds a JOIN clause to the query.
   *
   * @param {string} table - The table to join.
   * @param {string} column1 - The column from the current table.
   * @param {string} operator - The comparison operator (e.g., '=', '>', '<').
   * @param {string} column2 - The column from the joined table.
   * @returns {Table} - Returns the current instance of Table for method chaining.
   *
   * @example
   * const users = await db.table('users').join('orders', 'users.id', '=', 'orders.user_id').get();
   * console.log(users); // [{ id: 1, name: 'John', order_id: 101 }]
   */
  join(table, column1, operator, column2) {
    const clone = this.clone();
    clone.dml.joins.push({
      type: "INNER",
      table,
      on: {
        column1,
        operator,
        column2
      }
    });
    return clone;
  }
  /**
   * Adds a LEFT JOIN clause to the query.
   *
   * @param {string} table - The table to join.
   * @param {string} column1 - The column from the current table.
   * @param {string} operator - The comparison operator (e.g., '=', '>', '<').
   * @param {string} column2 - The column from the joined table.
   * @returns {Table} - Returns the current instance of Table for method chaining.
   *
   * @example
   * const users = await db.table('users').leftJoin('orders', 'users.id', '=', 'orders.user_id').get();
   * console.log(users); // [{ id: 1, name: 'John', order_id: 101 }, { id: 2, name: 'Jane', order_id: null }]
   */
  leftJoin(table, column1, operator, column2) {
    const clone = this.clone();
    clone.dml.joins.push({
      type: "LEFT",
      table,
      on: {
        column1,
        operator,
        column2
      }
    });
    return clone;
  }
  /**
   * Adds a RIGHT JOIN clause to the query.
   *
   * @param {string} table - The table to join.
   * @param {string} column1 - The column from the current table.
   * @param {string} operator - The comparison operator (e.g., '=', '>', '<').
   * @param {string} column2 - The column from the joined table.
   * @returns {Table} - Returns the current instance of Table for method chaining.
   *
   * @example
   * const users = await db.table('users').rightJoin('orders', 'users.id', '=', 'orders.user_id').get();
   * console.log(users); // [{ id: 1, name: 'John', order_id: 101 }, { id: null, name: null, order_id: 102 }]
   */
  rightJoin(table, column1, operator, column2) {
    const clone = this.clone();
    clone.dml.joins.push({
      type: "RIGHT",
      table,
      on: {
        column1,
        operator,
        column2
      }
    });
    return clone;
  }
  /**
   * Adds an ORDER BY clause to the query.
   *
   * @param {string} column - The column to order by.
   * @param {'ASC' | 'DESC'} direction - The sorting direction ('ASC' or 'DESC').
   * @returns {Table} - Returns the current instance of Table for method chaining.
   *
   * @example
   * const users = await db.table('users').orderBy('name', 'ASC').get();
   * console.log(users); // [{ id: 2, name: 'Jane' }, { id: 1, name: 'John' }]
   */
  orderBy(column, direction = "ASC") {
    const clone = this.clone();
    const validDirections = ["ASC", "DESC"];
    if (validDirections.includes(direction.toUpperCase())) {
      clone.dml.orderBy.push({
        column,
        direction: direction.toUpperCase()
      });
    } else {
      throw new Error(`Invalid direction: ${direction}. Use 'ASC' or 'DESC'.`);
    }
    return clone;
  }
  /**
   * Adds a GROUP BY clause to the query.
   *
   * @param {string} column - The column to group by.
   * @returns {Table} - Returns the current instance of Table for method chaining.
   *
   * @example
   * const users = await db.table('users').groupBy('age').get();
   * console.log(users); // [{ age: 30, count: 1 }, { age: 25, count: 1 }]
   */
  groupBy(column) {
    const clone = this.clone();
    clone.dml.groupBy.push(column);
    return clone;
  }
  /**
   * Adds a DISTINCT clause to the query.
   *
   * @returns {Table} - Returns the current instance of Table for method chaining.
   *
   * @example
   * const users = await db.table('users').distinct().select(['name']).get();
   * console.log(users); // [{ name: 'John' }, { name: 'Jane' }]
   */
  distinct() {
    const clone = this.clone();
    clone.dml.distinct = true;
    return clone;
  }
  /**
   * Adds a COUNT clause to the query.
   *
   * @param {string} column - The column to count (default is '*').
   * @returns {Table} - Returns the current instance of Table for method chaining.
   *
   * @example
   * const count = await db.table('users').count().first();
   * console.log(count); // { count: 2 }
   */
  async count(column = "*") {
    const clone = this.clone();
    clone.dml.type = "select";
    clone.dml.aggregation = {
      type: "COUNT",
      column,
      alias: "count"
    };
    clone.dml.columns = [`COUNT(${column}) AS count`];
    clone.dml.data = null;
    clone.dml.limit = null;
    clone.dml.offset = null;
    try {
      const result = await clone.getResponse();
      const res = result[0] || null;
      if (res) {
        return res.count;
      }
      return 0;
    } catch (error) {
      throw error;
    }
  }
  /**
   * Adds a SUM clause to the query.
   *
   * @param {string} column - The column to sum.
   * @returns {Table} - Returns the current instance of Table for method chaining.
   *
   * @example
   * const totalAge = await db.table('users').sum('age').first();
   * console.log(totalAge); // { sum: 55 }
   */
  async sum(column) {
    const clone = this.clone();
    clone.dml.type = "select";
    clone.dml.aggregation = {
      type: "SUM",
      column,
      alias: "sum"
    };
    clone.dml.columns = [`SUM(${column}) AS sum`];
    clone.dml.data = null;
    clone.dml.limit = 1;
    try {
      const result = await clone.getResponse();
      const res = result[0] || null;
      if (res) {
        return res.sum;
      }
      return 0;
    } catch (error) {
      throw error;
    }
  }
  /**
   * Adds an AVG clause to the query.
   *
   * @param {string} column - The column to calculate the average.
   * @returns {Table} - Returns the current instance of Table for method chaining.
   *
   * @example
   * const avgAge = await db.table('users').avg('age').first();
   * console.log(avgAge); // { avg: 27.5 }
   */
  async avg(column) {
    const clone = this.clone();
    clone.dml.type = "select";
    clone.dml.aggregation = {
      type: "AVG",
      column,
      alias: "avg"
    };
    clone.dml.columns = [`AVG(${column}) AS avg`];
    clone.dml.data = null;
    clone.dml.limit = 1;
    try {
      const result = await clone.getResponse();
      const res = result[0] || null;
      if (res) {
        return res.avg;
      }
      return 0;
    } catch (error) {
      throw error;
    }
  }
  /**
   * Adds a MAX clause to the query.
   *
   * @param {string} column - The column to find the maximum value.
   * @returns {Table} - Returns the current instance of Table for method chaining.
   *
   * @example
   * const maxAge = await db.table('users').max('age').first();
   * console.log(maxAge); // { max: 30 }
   */
  async max(column) {
    const clone = this.clone();
    clone.dml.type = "select";
    clone.dml.aggregation = {
      type: "MAX",
      column,
      alias: "max"
    };
    clone.dml.columns = [`MAX(${column}) AS max`];
    clone.dml.data = null;
    clone.dml.limit = 1;
    try {
      const result = await clone.getResponse();
      const res = result[0] || null;
      if (res) {
        return res.max;
      }
      return 0;
    } catch (error) {
      throw error;
    }
  }
  /**
   * Adds a MIN clause to the query.
   *
   * @param {string} column - The column to find the minimum value.
   * @returns {Table} - Returns the current instance of Table for method chaining.
   *
   * @example
   * const minAge = await db.table('users').min('age').first();
   * console.log(minAge); // { min: 25 }
   */
  async min(column) {
    const clone = this.clone();
    clone.dml.type = "select";
    clone.dml.aggregation = {
      type: "MIN",
      column,
      alias: "min"
    };
    clone.dml.columns = [`MIN(${column}) AS min`];
    clone.dml.data = null;
    clone.dml.limit = 1;
    try {
      const result = await clone.getResponse();
      const res = result[0] || null;
      if (res) {
        return res.min;
      }
      return 0;
    } catch (error) {
      throw error;
    }
  }
  /**
   * Adds a LIMIT clause to the query.
   *
   * @param {number} number - The maximum number of rows to return.
   * @returns {Table} - Returns the current instance of Table for method chaining.
   *
   * @example
   * const users = await db.table('users').limit(1).get();
   * console.log(users); // [{ id: 1, name: 'John', age: 30 }]
   */
  limit(number) {
    const clone = this.clone();
    clone.dml.limit = Number(number);
    return clone;
  }
  /**
   * Adds pagination to the query using LIMIT and OFFSET.
   *
   * @param {number} number - The page number (starting from 1).
   * @returns {Table} - Returns the current instance of Table for method chaining.
   *
   * @example
   * const users = await db.table('users').limit(1).page(2).get();
   * console.log(users); // [{ id: 2, name: 'Jane', age: 25 }]
   */
  page(number) {
    const clone = this.clone();
    const pageNum = Number(number);
    if (clone.dml.limit) {
      clone.dml.offset = (pageNum - 1) * clone.dml.limit;
    }
    return clone;
  }
  /**
  * Executes the query and returns all matching rows.
  *
  * @returns {Promise<DatabaseRecord[]>} - Returns an array of rows.
  *
  * @example
  * const users = await db.table('users').get();
  * console.log(users); // [{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }]
  */
  async get() {
    try {
      const clone = this.clone();
      clone.dml.type = "select";
      clone.dml.data = null;
      clone.dml.aggregation = null;
      const result = await clone.getResponse();
      return result;
    } catch (error) {
      throw error;
    }
  }
  /**
   * Executes the query and returns the first matching row.
   *
   * @returns {Promise<DatabaseRecord | null>} - Returns the first row or null if no rows match.
   *
   * @example
   * const user = await db.table('users').first();
   * console.log(user); // { id: 1, name: 'John' }
   */
  async first() {
    const clone = this.clone();
    clone.dml.type = "select";
    clone.dml.data = null;
    clone.dml.aggregation = null;
    clone.dml.limit = 1;
    try {
      const result = await clone.getResponse();
      return result[0] || null;
    } catch (error) {
      throw error;
    }
  }
  /**
   * Finds a row by a specific column value.
   *
   * @param {any} value - The value to search for.
   * @param {string} column - The column to search in (default is 'id').
   * @returns {Promise<DatabaseRecord | null>} - Returns the first matching row or null if no rows match.
   *
   * @example
   * const user = await db.table('users').find(1);
   * console.log(user); // { id: 1, name: 'John' }
   */
  async find(value, column = "id") {
    const clone = this.clone();
    clone.dml.type = "select";
    clone.dml.data = null;
    clone.dml.aggregation = null;
    clone.where(column, "=", value);
    clone.dml.limit = 1;
    try {
      const result = await clone.getResponse();
      return result[0] || null;
    } catch (error) {
      throw error;
    }
  }
  /**
   * Inserts one or more rows into the table.
   *
   * @param {DatabaseRecord[]} data - An array of objects representing the rows to insert.
   * @returns {Promise<DatabaseRecord[]>} - Returns an array of the inserted rows.
   *
   * @example
   * const newUsers = await db.table('users').insert([
   *     { name: 'Alice', age: 28 },
   *     { name: 'Bob', age: 32 }
   * ]);
   * 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.");
    }
    clone.dml.type = "insert";
    clone.dml.data = data;
    await clone.getResponse(clone.dml, "Add");
    return data;
  }
  /**
   * Updates rows in the table based on the defined conditions.
   *
   * @param {DatabaseRecord} data - An object with key-value pairs representing the fields to update.
   * @returns {Promise<any>} - Returns the result of the update operation.
   *
   * @example
   * const result = await db.table('users')
   *     .where('id', '=', 1)
   *     .update({ name: 'John Updated', age: 31 });
   * 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) {
      throw new Error("You must specify at least one WHERE condition to perform an update.");
    }
    clone.dml.type = "update";
    clone.dml.data = data;
    await clone.getResponse(clone.dml, "Update");
    return data;
  }
  /**
   * Deletes rows from the table based on the defined conditions.
   *
   * @returns {Promise<any>} - Returns the result of the delete operation.
   *
   * @example
   * const result = await db.table('users').where('id', '=', 1).delete();
   * console.log(result); // { affectedRows: 1 }
   */
  async delete() {
    const clone = this.clone();
    if (clone.dml.where.length === 0) {
      throw new Error("You must specify at least one WHERE condition to perform a delete.");
    }
    clone.dml.type = "delete";
    const deleteData = await clone.getResponse(clone.dml, "Delete");
    return deleteData;
  }
  async getResponse(dml = null, type = null) {
    const localDML = dml ? dml : this.dml;
    const computedFieldsNeeded = [];
    let dependeciesArrray = [];
    if (this.computedFields.length > 0) {
      let columns = localDML.columns;
      for (const field of localDML.columns) {
        const computedField = this.computedFields.find((cf) => cf.column === field);
        if (computedField) {
          computedFieldsNeeded.push(computedField);
          const dependencies = import_core2.ComputedFieldProcessor.extractDependencies(computedField.instruction);
          dependeciesArrray = [...dependeciesArrray, ...dependencies];
          columns = Array.from(/* @__PURE__ */ new Set([...columns, ...dependencies]));
          columns = columns.filter((col) => col != field);
        }
      }
      localDML.columns = columns;
    }
    let arrayResult = [];
    if (type) {
      const beffore = this.trigger.get("before" + type);
      const after = this.trigger.get("after" + type);
      if (this.triggers.length > 0 && (beffore || after)) {
        const dataset = localDML.data;
        for (let index = 0; index < dataset.length; index++) {
          const data = dataset[index];
          const newDML = { ...localDML, data: [data] };
          if (beffore) {
            const interceptor = await this.trigger.execute("before" + type, data);
            const response = await this.engine.run("query_engine", [
              "--action",
              "execute",
              "--dml",
              JSON.stringify(newDML)
            ]);
            if (response.status != 200) {
              interceptor.discard();
              returnFormattedError(response.status, response.message);
            }
            await interceptor.commit();
            arrayResult = response.data;
          }
          if (after) {
            const response = await this.engine.run("query_engine", [
              "--action",
              "execute",
              "--dml",
              JSON.stringify(newDML)
            ]);
            if (response.status != 200) {
              returnFormattedError(response.status, response.message);
            }
            const interceptor = await this.trigger.execute("after" + type, data);
            await interceptor.commit();
          }
        }
      } else {
        const response = await this.engine.run("query_engine", [
          "--action",
          "execute",
          "--dml",
          JSON.stringify(localDML)
        ]);
        if (response.status != 200) {
          returnFormattedError(response.status, response.message);
        }
        arrayResult = response.data;
      }
    } else {
      const response = await this.engine.run("query_engine", [
        "--action",
        "execute",
        "--dml",
        JSON.stringify(localDML)
      ]);
      if (response.status != 200) {
        returnFormattedError(response.status, response.message);
      }
      arrayResult = response.data;
    }
    if (computedFieldsNeeded.length > 0) {
      let newDataset = import_core2.ComputedFieldProcessor.computedFields(arrayResult, computedFieldsNeeded);
      const result = newDataset.map((obj) => {
        const newObj = { ...obj };
        dependeciesArrray.forEach((key) => delete newObj[key]);
        return newObj;
      });
      return result;
    }
    return arrayResult;
  }
  clone() {
    const cloned = Object.create(Object.getPrototypeOf(this));
    cloned.engine = this.engine;
    cloned.nextType = this.nextType;
    cloned.computedFields = this.computedFields;
    cloned.trigger = this.trigger;
    cloned.triggers = this.triggers;
    cloned.dml = {
      ...this.dml,
      columns: [...this.dml.columns],
      joins: [...this.dml.joins],
      where: [...this.dml.where],
      orderBy: [...this.dml.orderBy],
      groupBy: [...this.dml.groupBy],
      // Clonar propiedades que faltaban para evitar mutación compartida
      data: this.dml.data ? Array.isArray(this.dml.data) ? [...this.dml.data] : { ...this.dml.data } : null,
      aggregation: this.dml.aggregation ? { ...this.dml.aggregation } : null
    };
    return cloned;
  }
};
function returnFormattedError(status, message) {
  const RESET = "\x1B[0m";
  const RED = "\x1B[31m";
  const YELLOW = "\x1B[33m";
  const BOLD = "\x1B[1m";
  const CYAN = "\x1B[36m";
  const GRAY = "\x1B[90m";
  const UNDERLINE = "\x1B[4m";
  const MAGENTA = "\x1B[35m";
  let output = "";
  let help = "";
  const color = status === 600 ? YELLOW : RED;
  if (message.includes("[help]")) {
    const parts = message.split("[help]");
    output += `
${RED}${BOLD}${parts[0]}${RESET}`;
    help += `
${MAGENTA}${BOLD}[help]${RESET} ${GRAY}${parts[1]}${RESET}
`;
  } else {
    output += `
${color}${BOLD}${message}${RESET}
`;
  }
  const err = new Error();
  const stackLines = err.stack?.split("\n") || [];
  const relevantStackLine = stackLines.find(
    (line) => line.includes(".js:") && !line.includes("node_modules")
  );
  if (relevantStackLine) {
    const match = relevantStackLine.match(/\((.*):(\d+):(\d+)\)/) || relevantStackLine.match(/at (.*):(\d+):(\d+)/);
    if (match) {
      const [, filePath, lineStr, columnStr] = match;
      const lineNum = parseInt(lineStr, 10);
      const errorLocation = `${filePath}:${lineStr}:${columnStr}`;
      try {
        const codeLines = import_fs.default.readFileSync(filePath, "utf-8").split("\n");
        const start = Math.max(0, lineNum - 3);
        const end = Math.min(codeLines.length, lineNum + 2);
        output += `
${CYAN}${BOLD}[code] ${RESET}${YELLOW} ${UNDERLINE}${errorLocation}${RESET}
`;
        for (let i = start; i < end; i++) {
          const line = codeLines[i];
          const lineLabel = `${i + 1}`.padStart(4, " ");
          const pointer = i + 1 === lineNum ? `${RED}<-${RESET}` : "  ";
          output += `${GRAY}${lineLabel}${RESET} ${pointer} ${line}
`;
        }
      } catch (err2) {
        output += `${YELLOW}\u26A0\uFE0F No se pudo leer el archivo de origen: ${filePath}${RESET}
`;
        output += `
${CYAN}${BOLD}Stack Trace:${RESET}
${stackLines.slice(2).join("\n")}
`;
      }
    }
  }
  output += help;
  console.error(output);
}

// src/index.ts
var index_default = Database;
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  Database,
  Table
});
//# sourceMappingURL=index.cjs.map