@zuzjs/orm 0.3.6 → 0.3.8

package/dist/drivers/queryBuilder.d.ts

@@ -1,162 +0,0 @@
-import { QueryResult } from "mysql2";
-import { ObjectLiteral, Repository } from "typeorm";
-import { QueryDeepPartialEntity } from "typeorm/query-builder/QueryPartialEntity";
-import { PartialConditions, QueryAction } from "../types";
-import ZormExprBuilder from "./expressionBuilder";
-declare class ZormQueryBuilder<T extends ObjectLiteral, R = QueryResult> extends Promise<R> {
-    private repository;
-    private queryBuilder;
-    private entityAlias;
-    private action;
-    private queryValues;
-    private usePromise;
-    private whereCount;
-    private isActiveRecord;
-    private activeRecord;
-    private joinedAliases;
-    constructor(repository: Repository<T>, _action: QueryAction, _usePromise?: boolean);
-    _create(): this;
-    upsert(): this;
-    _update(): this;
-    _delete(): this;
-    _getRawQuery(): [string, any[]];
-    active(): this;
-    _saveActiveRecord(activeRecord: T): Promise<T | null>;
-    clone(): ZormQueryBuilder<T, R>;
-    /**
-     * Sets the values for an insert or update query.
-     * @param data - The data to be inserted or updated.
-     * @returns The current instance of ZormQueryBuilder.
-     */
-    with(data: QueryDeepPartialEntity<T> | QueryDeepPartialEntity<T[]>): this;
-    /**
-     * Sets the values for an insert or update query.
-     * @param data - The data to be inserted or updated.
-     * @returns The current instance of ZormQueryBuilder.
-     */
-    withData(data: QueryDeepPartialEntity<T> | QueryDeepPartialEntity<T[]>): this;
-    /**
-     * Specifies the fields to be selected in a select query.
-     * @param fields - The fields to be selected.
-     * @returns The current instance of ZormQueryBuilder.
-     */
-    select(fields: (keyof T)[]): this;
-    private applyCondition;
-    /**
-     * Adds a custom expression-based WHERE clause using a fluent builder.
-     * @param fn - A callback that receives a ZormExprBuilder and returns an expression + param.
-     */
-    expression(exprFn: (q: ZormExprBuilder<T>) => ZormExprBuilder<T>, 
-    /** Add parentheses group to built expression */
-    group?: boolean): this;
-    /**
-     * Adds a WHERE condition to the query.
-     * @param condition - The condition to be added.
-     * @returns The current instance of ZormQueryBuilder.
-     */
-    where(condition: PartialConditions<T>): this;
-    /**
-     * Adds an OR condition to the query.
-     * @param condition - The condition to be added.
-     * @returns The current instance of ZormQueryBuilder.
-     */
-    or(condition: PartialConditions<T>): this;
-    /**
-     * Adds an ORDER BY clause to the query.
-     * @param field - The field to order by.
-     * @param direction - The direction of the order (ASC or DESC).
-     * @returns The current instance of ZormQueryBuilder.
-     */
-    orderBy(field: keyof T, direction?: "ASC" | "DESC"): this;
-    /**
-     * Adds a LIMIT clause to the query.
-     * @param n - The maximum number of records to return.
-     * @returns The current instance of ZormQueryBuilder.
-     */
-    limit(n: number): this;
-    /**
-     * Adds an OFFSET clause to the query.
-     * @param n - The number of records to skip.
-     * @returns The current instance of ZormQueryBuilder.
-     */
-    offset(n: number): this;
-    /**
-     * Adds relations to be included in the query.
-     * @param relations - The relations to be included.
-     * @returns The current instance of ZormQueryBuilder.
-     */
-    withRelation(rel: string, ...more: string[]): this;
-    /**
-     * Adds an INNER JOIN clause to the query.
-     * @param relation - The relation to join.
-     * @param alias - The alias for the joined relation.
-     * @param condition - Optional condition for the join.
-     * @returns The current instance of ZormQueryBuilder.
-     */
-    innerJoin(relation: string, alias: string, condition?: string): this;
-    /**
-     * Adds a LEFT JOIN clause to the query.
-     * @param relation - The relation to join.
-     * @param alias - The alias for the joined relation.
-     * @param condition - Optional condition for the join.
-     * @returns The current instance of ZormQueryBuilder.
-     */
-    leftJoin(relation: string, alias: string, condition?: string): this;
-    /**
-     * Adds a GROUP BY clause to the query.
-     * @param field - The field to group by.
-     * @returns The current instance of ZormQueryBuilder.
-     */
-    groupBy(field: keyof T): this;
-    /**
-     * Adds a HAVING clause to the query.
-     * @param condition - The condition for the HAVING clause.
-     * @returns The current instance of ZormQueryBuilder.
-     */
-    having(condition: string): this;
-    /**
-     * Adds an IN clause to the query.
-     * @param field - The field to check.
-     * @param values - The values for the IN clause.
-     * @returns The current instance of ZormQueryBuilder.
-     */
-    in(field: keyof T, values: any[]): this;
-    /**
-     * Adds a LIKE condition to the query, supporting both single and multiple values.
-     * If an array is provided, it uses OR conditions between them.
-     * @param field - The field to apply the LIKE condition on.
-     * @param value - A string or an array of strings to match.
-     * @returns The current instance of ZormQueryBuilder.
-     */
-    like(conditions: Partial<Record<keyof T, string | string[]>>, mode: "contains" | "startsWith" | "endsWith" | "exact"): this;
-    /**
-     * Adds a DISTINCT clause to the query.
-     * @returns The current instance of ZormQueryBuilder.
-     */
-    distinct(): this;
-    count(field?: keyof T): Promise<number>;
-    sum(field: keyof T): Promise<number>;
-    avg(field: keyof T): Promise<number>;
-    min(field: keyof T): Promise<number>;
-    max(field: keyof T): Promise<number>;
-    /**
-     * Executes a raw SQL query.
-     * @param sql - The raw SQL query.
-     * @param params - Optional parameters for the query.
-     * @returns A promise that resolves with the query result.
-     */
-    rawQuery(sql: string, params?: any): Promise<any>;
-    /**
-     * Executes the query and returns the result.
-     * @returns A promise that resolves with the query result.
-     */
-    execute(): Promise<R>;
-    /**
-     * Handles the fulfillment and rejection of the promise.
-     * @param onfulfilled - The callback to execute when the promise is fulfilled.
-     * @param onrejected - The callback to execute when the promise is rejected.
-     * @returns A promise that resolves with the result of the callback.
-     */
-    then<TResult1 = R, TResult2 = never>(onfulfilled?: ((value: R) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
-}
-export default ZormQueryBuilder;

package/dist/drivers/queryBuilder.js

@@ -1,518 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_1 = require("../core");
-const expressionBuilder_1 = __importDefault(require("./expressionBuilder"));
-const index_js_1 = require("./mysql/index.js");
-class ZormQueryBuilder extends Promise {
-    repository;
-    queryBuilder;
-    entityAlias;
-    action;
-    queryValues = null;
-    usePromise;
-    whereCount = 0;
-    isActiveRecord = false;
-    activeRecord;
-    joinedAliases = {};
-    // private currentWhereLogic: 'AND' | 'OR' = 'AND';
-    constructor(repository, _action, _usePromise) {
-        super(() => { }); // Required for extending Promise
-        this.repository = repository;
-        this.entityAlias = repository.metadata.tableName;
-        this.queryBuilder = repository.createQueryBuilder(this.entityAlias);
-        this.action = _action;
-        this.usePromise = _usePromise || false;
-        this.activeRecord = null;
-        // switch (_action) {
-        //     case "create":
-        //     case "upsert":
-        //         this.queryBuilder = repository.createQueryBuilder(this.entityAlias) as InsertQueryBuilder<ObjectLiteral>;
-        //         break;
-        //     case "update":
-        //         this.queryBuilder = repository.createQueryBuilder(this.entityAlias).update() as UpdateQueryBuilder<T>;
-        //         break;
-        //     case "delete":
-        //         this.queryBuilder = repository.createQueryBuilder(this.entityAlias).delete() as DeleteQueryBuilder<T>;
-        //         break;
-        //     case "select":
-        //     default:
-        //         this.queryBuilder = repository.createQueryBuilder(this.entityAlias) as SelectQueryBuilder<T>;
-        //         break;
-        // }
-    }
-    _create() {
-        if (this.queryValues) {
-            this.queryBuilder = this.queryBuilder
-                .insert()
-                .into(this.entityAlias)
-                .values(this.queryValues);
-        }
-        else
-            throw (0, core_1.stackTrace)(`○ Values are missing. You forgot to call .with({ key: value })`);
-        return this;
-    }
-    upsert() {
-        if (this.queryValues) {
-            this.queryBuilder = this.repository.createQueryBuilder(this.entityAlias)
-                .insert()
-                .into(this.entityAlias)
-                .values(this.queryValues)
-                .orUpdate(Object.keys(this.queryValues));
-        }
-        else
-            throw (0, core_1.stackTrace)(`○ Values are missing. You forgot to call .with({ key: value })`);
-        return this;
-    }
-    _update() {
-        if (this.queryValues) {
-            if (this.whereCount > 0) {
-                this.queryBuilder = this.queryBuilder
-                    .update()
-                    .set(this.queryValues);
-            }
-            else {
-                throw (0, core_1.stackTrace)(`○ Update must have at least one WHERE condition. You forgot to call .where({ condition: value })`);
-            }
-        }
-        else
-            throw (0, core_1.stackTrace)(`○ Values are missing. You forgot to call .with({ key: value })`);
-        return this;
-    }
-    _delete() {
-        if (this.whereCount > 0) {
-            this.queryBuilder = this.queryBuilder.delete();
-        }
-        else {
-            throw (0, core_1.stackTrace)(`○ Delete must have at least one WHERE condition. You forgot to call .where({ condition: value })`);
-        }
-        return this;
-    }
-    _getRawQuery() {
-        return this.queryBuilder.getQueryAndParameters();
-    }
-    active() {
-        this.isActiveRecord = true;
-        return this;
-    }
-    async _saveActiveRecord(activeRecord) {
-        // if (!this.activeRecord) throw new Error("No active record found. Use `findOne` first.");
-        return this.repository.save(activeRecord);
-        // return this
-    }
-    clone() {
-        const cloned = new ZormQueryBuilder(this.repository, this.action, this.usePromise);
-        cloned.queryBuilder = this.queryBuilder.clone(); // Deep clone of query builder
-        cloned.entityAlias = this.entityAlias;
-        cloned.queryValues = this.queryValues ? structuredClone(this.queryValues) : null;
-        cloned.whereCount = this.whereCount;
-        cloned.isActiveRecord = this.isActiveRecord;
-        cloned.activeRecord = this.activeRecord;
-        return cloned;
-    }
-    /**
-     * Sets the values for an insert or update query.
-     * @param data - The data to be inserted or updated.
-     * @returns The current instance of ZormQueryBuilder.
-     */
-    with(data) {
-        this.queryValues = data;
-        return this;
-    }
-    /**
-     * Sets the values for an insert or update query.
-     * @param data - The data to be inserted or updated.
-     * @returns The current instance of ZormQueryBuilder.
-     */
-    withData(data) {
-        this.queryValues = data;
-        return this;
-    }
-    /**
-     * Specifies the fields to be selected in a select query.
-     * @param fields - The fields to be selected.
-     * @returns The current instance of ZormQueryBuilder.
-     */
-    select(fields) {
-        this.queryBuilder
-            .select(fields.map(field => `${this.entityAlias}.${String(field)}`));
-        return this;
-    }
-    applyCondition(qb, condition, type) {
-        Object.entries(condition).forEach(([key, value], index) => {
-            const paramKey = `${key}Param${index}_${this.whereCount}`; // Unique parameter name
-            let sqlOperator = "="; // Default to "="
-            if (typeof value === "string") {
-                const match = value.match(/^(!=|>=|<=|>|<|=)\s*(.+)$/); // Improved regex
-                if (match) {
-                    const [, operator, rawValue] = match;
-                    sqlOperator = operator; // Directly use the matched operator
-                    const parsedValue = !isNaN(Number(rawValue)) ? Number(rawValue) : rawValue.trim(); // Convert to number if possible
-                    qb[type](`${qb.alias}.${key} ${sqlOperator} :${paramKey}`, { [paramKey]: parsedValue });
-                    return;
-                }
-            }
-            else if (typeof value === "object" && value !== null) {
-                // Support object-based conditions: { age: { gt: 18, lt: 20 } }
-                const operators = {
-                    gt: ">",
-                    gte: ">=",
-                    lt: "<",
-                    lte: "<=",
-                    ne: "!=",
-                    eq: "="
-                };
-                Object.entries(value).forEach(([opKey, opValue]) => {
-                    if (operators[opKey]) {
-                        const paramKey = `${key}Param_${opKey}_${this.whereCount++}`; // Unique param key
-                        qb[type](`${qb.alias}.${key} ${operators[opKey]} :${paramKey}`, { [paramKey]: opValue });
-                    }
-                });
-                return; // Prevent default equality case for objects
-            }
-            // Default case (normal equality condition)
-            qb[type](`${this.entityAlias}.${key} = :${paramKey}`, { [paramKey]: value });
-            this.whereCount++;
-        });
-    }
-    /**
-     * Adds a custom expression-based WHERE clause using a fluent builder.
-     * @param fn - A callback that receives a ZormExprBuilder and returns an expression + param.
-     */
-    expression(exprFn, 
-    /** Add parentheses group to built expression */
-    group = true) {
-        const qb = this.queryBuilder;
-        const result = exprFn(new expressionBuilder_1.default(this.entityAlias));
-        const _expression = result.buildExpression();
-        qb.andWhere(group ? `(${_expression})` : _expression, result.buildParams());
-        this.whereCount++;
-        return this;
-    }
-    // expression(exprFn: (q: ZormExprBuilder<T>) => ZormExprBuilder<T>): this {
-    //     const qb = this.queryBuilder as SelectQueryBuilder<T> | UpdateQueryBuilder<T>;
-    //     const result = exprFn(new ZormExprBuilder<T>(this.entityAlias));
-    //     // const expression = 
-    //     qb.andWhere(result.buildExpression(), result.buildParams());
-    //     // if ('expression' in result && 'param' in result) {
-    //     // } else {
-    //     //     // fallback if only expression was built without .equals()
-    //     // }
-    //     // qb.andWhere(result.buildExpression(), result.buildParams());
-    //     this.whereCount++;
-    //     return this;
-    // }
-    /**
-     * Adds a WHERE condition to the query.
-     * @param condition - The condition to be added.
-     * @returns The current instance of ZormQueryBuilder.
-     */
-    where(condition) {
-        const qb = this.queryBuilder;
-        this.applyCondition(qb, condition, `andWhere`);
-        return this;
-    }
-    /**
-     * Adds an OR condition to the query.
-     * @param condition - The condition to be added.
-     * @returns The current instance of ZormQueryBuilder.
-     */
-    or(condition) {
-        const qb = this.queryBuilder;
-        this.applyCondition(qb, condition, `orWhere`);
-        return this;
-    }
-    /**
-     * Adds an ORDER BY clause to the query.
-     * @param field - The field to order by.
-     * @param direction - The direction of the order (ASC or DESC).
-     * @returns The current instance of ZormQueryBuilder.
-     */
-    orderBy(field, direction = "ASC") {
-        this.queryBuilder.orderBy(`${this.entityAlias}.${String(field)}`, direction);
-        return this;
-    }
-    /**
-     * Adds a LIMIT clause to the query.
-     * @param n - The maximum number of records to return.
-     * @returns The current instance of ZormQueryBuilder.
-     */
-    limit(n) {
-        this.queryBuilder.limit(n);
-        return this;
-    }
-    /**
-     * Adds an OFFSET clause to the query.
-     * @param n - The number of records to skip.
-     * @returns The current instance of ZormQueryBuilder.
-     */
-    offset(n) {
-        this.queryBuilder.offset(n);
-        return this;
-    }
-    /**
-     * Adds relations to be included in the query.
-     * @param relations - The relations to be included.
-     * @returns The current instance of ZormQueryBuilder.
-     */
-    withRelation(rel, ...more) {
-        [rel, ...more].forEach(relation => this.queryBuilder.leftJoinAndSelect(`${this.entityAlias}.${relation}`, relation));
-        return this;
-    }
-    /**
-     * Adds an INNER JOIN clause to the query.
-     * @param relation - The relation to join.
-     * @param alias - The alias for the joined relation.
-     * @param condition - Optional condition for the join.
-     * @returns The current instance of ZormQueryBuilder.
-     */
-    innerJoin(relation, alias, condition) {
-        if (condition) {
-            this.queryBuilder.innerJoin(`${this.entityAlias}.${relation}`, alias, condition);
-        }
-        else {
-            this.queryBuilder.innerJoin(`${this.entityAlias}.${relation}`, alias);
-        }
-        this.joinedAliases[alias] = relation;
-        return this;
-    }
-    /**
-     * Adds a LEFT JOIN clause to the query.
-     * @param relation - The relation to join.
-     * @param alias - The alias for the joined relation.
-     * @param condition - Optional condition for the join.
-     * @returns The current instance of ZormQueryBuilder.
-     */
-    leftJoin(relation, alias, condition) {
-        if (condition) {
-            this.queryBuilder.leftJoin(`${this.entityAlias}.${relation}`, alias, condition);
-        }
-        else {
-            this.queryBuilder.leftJoin(`${this.entityAlias}.${relation}`, alias);
-        }
-        this.joinedAliases[alias] = relation;
-        return this;
-    }
-    /**
-     * Adds a GROUP BY clause to the query.
-     * @param field - The field to group by.
-     * @returns The current instance of ZormQueryBuilder.
-     */
-    groupBy(field) {
-        this.queryBuilder.groupBy(`${this.entityAlias}.${String(field)}`);
-        return this;
-    }
-    /**
-     * Adds a HAVING clause to the query.
-     * @param condition - The condition for the HAVING clause.
-     * @returns The current instance of ZormQueryBuilder.
-     */
-    having(condition) {
-        this.queryBuilder.having(condition);
-        return this;
-    }
-    /**
-     * Adds an IN clause to the query.
-     * @param field - The field to check.
-     * @param values - The values for the IN clause.
-     * @returns The current instance of ZormQueryBuilder.
-     */
-    in(field, values) {
-        this.queryBuilder.andWhere(`${this.entityAlias}.${String(field)} IN (:...values)`, { values });
-        this.whereCount++;
-        return this;
-    }
-    /**
-     * Adds a LIKE condition to the query, supporting both single and multiple values.
-     * If an array is provided, it uses OR conditions between them.
-     * @param field - The field to apply the LIKE condition on.
-     * @param value - A string or an array of strings to match.
-     * @returns The current instance of ZormQueryBuilder.
-     */
-    like(conditions, mode) {
-        if (!conditions || Object.keys(conditions).length === 0)
-            return this;
-        const qb = this.queryBuilder;
-        const orConditions = [];
-        const params = {};
-        Object.entries(conditions).forEach(([field, value]) => {
-            const values = Array.isArray(value) ? value : [value];
-            const fieldConditions = [];
-            values.forEach((val, index) => {
-                const paramKey = `${field}LikeParam${index}_${this.whereCount}`;
-                fieldConditions.push(`${this.entityAlias}.${String(field)} LIKE :${paramKey}`);
-                let formattedVal = val;
-                switch (mode || "contains") {
-                    case "startsWith":
-                        formattedVal = `${val}%`;
-                        break;
-                    case "endsWith":
-                        formattedVal = `%${val}`;
-                        break;
-                    case "exact":
-                        formattedVal = `${val}`;
-                        break;
-                    case "contains":
-                    default:
-                        formattedVal = `%${val}%`;
-                }
-                params[paramKey] = formattedVal; // Directly use the value (supports %xyz% pattern)
-            });
-            if (fieldConditions.length > 0) {
-                orConditions.push(`(${fieldConditions.join(" OR ")})`);
-            }
-        });
-        if (orConditions.length > 0) {
-            qb.andWhere(`(${orConditions.join(" OR ")})`, params);
-            this.whereCount++;
-        }
-        return this;
-    }
-    /**
-     * Adds a DISTINCT clause to the query.
-     * @returns The current instance of ZormQueryBuilder.
-     */
-    distinct() {
-        this.queryBuilder.distinct(true);
-        return this;
-    }
-    async count(field) {
-        if (field) {
-            this.queryBuilder.select(`COUNT(${field})`);
-        }
-        return await this.queryBuilder.getCount();
-    }
-    async sum(field) {
-        const result = await this.queryBuilder.select(`SUM(${this.entityAlias}.${String(field)})`, "sum").getRawOne();
-        return result.sum || 0;
-    }
-    async avg(field) {
-        const result = await this.queryBuilder.select(`AVG(${this.entityAlias}.${String(field)})`, "avg").getRawOne();
-        return result.avg || 0;
-    }
-    async min(field) {
-        const result = await this.queryBuilder.select(`MIN(${this.entityAlias}.${String(field)})`, "min").getRawOne();
-        return result.min || 0;
-    }
-    async max(field) {
-        const result = await this.queryBuilder.select(`MAX(${this.entityAlias}.${String(field)})`, "max").getRawOne();
-        return result.max || 0;
-    }
-    /**
-     * Executes a raw SQL query.
-     * @param sql - The raw SQL query.
-     * @param params - Optional parameters for the query.
-     * @returns A promise that resolves with the query result.
-     */
-    async rawQuery(sql, params) {
-        return await this.repository.query(sql, params);
-    }
-    /**
-     * Executes the query and returns the result.
-     * @returns A promise that resolves with the query result.
-     */
-    async execute() {
-        const removedMethods = {};
-        Object.keys(Object.prototype).forEach((method) => {
-            if (Object.prototype.hasOwnProperty.call(Object.prototype, method)) {
-                removedMethods[method] = Object.prototype[method];
-                delete Object.prototype[method];
-            }
-        });
-        try {
-            switch (this.action) {
-                case "upsert":
-                case "create":
-                    this._create();
-                    const _create = await this.queryBuilder.execute();
-                    return {
-                        created: true,
-                        id: _create.raw.insertId,
-                        record: _create.generatedMaps[0],
-                        records: _create.generatedMaps.length > 1 ? _create.generatedMaps : null
-                    };
-                case "update":
-                    this._update();
-                    const _updateQuery = this.queryBuilder;
-                    const _update = await _updateQuery.execute();
-                    const whereQuery = _updateQuery.getQuery().split("WHERE")[1]?.trim(); // Get the WHERE clause
-                    const _get = this.repository
-                        .createQueryBuilder(this.entityAlias)
-                        .where(whereQuery, _updateQuery.getParameters()); // Use the same parameters
-                    // console.log(_updateQuery.getQueryAndParameters())
-                    const _updated = await _get.getMany();
-                    return {
-                        updated: _update.affected ? _update.affected > 0 : false,
-                        record: _updated[0],
-                        records: _updated.length > 1 ? _updated : []
-                    };
-                case "delete":
-                    this._delete();
-                    const _delete = await this.queryBuilder.execute();
-                    return {
-                        deleted: _delete.affected ? _delete.affected > 0 : false,
-                        count: _delete.affected || 0
-                    };
-                case "select":
-                default:
-                    const _select = await this.queryBuilder.getMany();
-                    const _result = {
-                        hasRows: _select.length > 0,
-                        count: _select.length,
-                        row: _select.length > 0 ? _select[0] : null,
-                        rows: _select.length == 1 ? [_select[0]] : _select,
-                    };
-                    if (this.isActiveRecord) {
-                        _result.save = () => this._saveActiveRecord(_select[0]);
-                    }
-                    return _result;
-            }
-        }
-        catch (err) {
-            const _e = err;
-            const error = {
-                code: index_js_1.MySQLErrorMap[_e.code] || _e.code,
-                message: _e.message,
-                query: _e.query, // The SQL query that caused the error
-                values: _e.parameters, // Parameters used in the query
-            };
-            switch (this.action) {
-                case "upsert":
-                case "create":
-                    const _c = {
-                        created: false,
-                        id: 0,
-                        error
-                    };
-                    return this.usePromise ? Promise.reject(_c) : _c;
-                case "update":
-                    const _u = { updated: false, error };
-                    return this.usePromise ? Promise.reject(_u) : _u;
-                case "delete":
-                    const _d = { deleted: false, error };
-                    return this.usePromise ? Promise.reject(_d) : _d;
-                case "select":
-                default:
-                    const _s = { hasRows: false, count: 0, row: null, rows: [], error };
-                    return this.usePromise ? Promise.reject(_s) : _s;
-            }
-        }
-        finally {
-            Object.entries(removedMethods).forEach(([method, fn]) => {
-                Object.prototype[method] = fn;
-            });
-        }
-    }
-    /**
-     * Handles the fulfillment and rejection of the promise.
-     * @param onfulfilled - The callback to execute when the promise is fulfilled.
-     * @param onrejected - The callback to execute when the promise is rejected.
-     * @returns A promise that resolves with the result of the callback.
-     */
-    then(onfulfilled, onrejected) {
-        return this.execute().then(onfulfilled, onrejected);
-    }
-}
-exports.default = ZormQueryBuilder;