@iamkirbki/database-handler-core 4.3.0 → 4.4.0

package/dist/helpers/QueryBuilders/QueryExpressionBuilder.js

@@ -0,0 +1,102 @@
+import SpatialDistanceExpression from "./ExpressionBuilders/SpatialDistanceExpression.js";
+import { UnknownExpressionTypeError } from "../Errors/ExpressionErrors/UnknownExpressionTypeError.js";
+import TextRelevanceExpression from "./ExpressionBuilders/TextRelevanceExpression.js";
+import JsonAggregateExpression from "./ExpressionBuilders/JsonAggregateExpression.js";
+/**
+ * A normalized, intermediate representation of a query expression.
+ *
+ * Expressions are NOT SQL strings directly — they are metadata-rich
+ * building blocks that later stages of the query builder can reason about.
+ *
+ * This is what allows:
+ * - base vs projection expressions
+ * - conditional query wrapping
+ * - expression-driven WHERE / ORDER BY injection
+ */
+/**
+ * Central factory and orchestration layer for query expressions.
+ *
+ * This class is intentionally:
+ * - static
+ * - registry-driven
+ * - dumb about SQL execution
+ *
+ * Its ONLY job is to translate abstract expressions
+ * into structured SQL fragments with metadata.
+ */
+class QueryExpressionBuilder {
+    static getExpressionDefaultRequirements(type) {
+        return this.expressionDefaults.get(type);
+    }
+    /**
+     * Registers a new expression builder at runtime.
+     *
+     * This is your “escape hatch” when core expressions
+     * are not enough.
+     *
+     * @param type - expression.type value
+     * @param builder - function that converts expression → expressionClause
+     */
+    static registerExpressionBuilder(type, builder) {
+        this.expressionBuilders.set(type, builder);
+    }
+    /**
+     * Converts high-level expression definitions into normalized clauses.
+     *
+     * Any expression without a registered builder is ignored
+     * (with a error, because silence is how bugs breed).
+     */
+    static buildExpressionsPart(expressions) {
+        const queryParts = [];
+        expressions.forEach(expression => {
+            const builder = this.expressionBuilders.get(expression.type);
+            if (builder) {
+                queryParts.push(builder(expression));
+            }
+            else {
+                throw new UnknownExpressionTypeError(expression.type);
+            }
+        });
+        return queryParts;
+    }
+}
+/**
+ * Registry mapping expression "type" → builder function.
+ *
+ * This allows:
+ * - zero switch statements
+ * - easy plugin-style extension
+ * - no touching core logic to add new expressions
+ */
+QueryExpressionBuilder.expressionBuilders = new Map([
+    [
+        'spatialDistance',
+        (expr) => new SpatialDistanceExpression().build(expr)
+    ],
+    [
+        'textRelevance',
+        (expr) => new TextRelevanceExpression().build(expr)
+    ],
+    [
+        'jsonAggregate',
+        (expr) => new JsonAggregateExpression().build(expr)
+    ]
+    // Future examples:
+    // ['jsonAggregation', (expr) => QueryExpressionBuilder.BuildJsonAggregation(expr)]
+    // ['windowFunction', (expr) => QueryExpressionBuilder.BuildWindowFunction(expr)]
+]);
+QueryExpressionBuilder.expressionDefaults = new Map([
+    [
+        'spatialDistance',
+        new SpatialDistanceExpression().defaultRequirements
+    ],
+    [
+        'textRelevance',
+        new TextRelevanceExpression().defaultRequirements
+    ],
+    [
+        'jsonAggregate',
+        new JsonAggregateExpression().defaultRequirements
+    ]
+]);
+export default QueryExpressionBuilder;

package/dist/helpers/QueryBuilders/QueryStatementBuilder.d.ts

@@ -0,0 +1,16 @@
+import { QueryWhereCondition, QueryComparisonParameters, QueryLayers, TableColumnInfo } from "../../types/index.js";
+export default class QueryStatementBuilder {
+    private _layers;
+    private _contexts;
+    private _tableColumnsCache;
+    private _valueClauseKeywords;
+    constructor(queryLayers: QueryLayers, tableColumnInformation?: Map<string, TableColumnInfo[]>);
+    build(): Promise<string>;
+    private buildBaseLayer;
+    private buildPrettyLayer;
+    private buildFinalLayer;
+    static normalizeAndQualifyConditions(where: QueryWhereCondition, tableName: string, normalizeBlacklist?: string[], valueClauseKeywords?: Set<string>): QueryComparisonParameters[];
+    static normalizeQueryConditions(where: QueryWhereCondition): QueryComparisonParameters[];
+    private addUnique;
+}
+//# sourceMappingURL=QueryStatementBuilder.d.ts.map

package/dist/helpers/QueryBuilders/QueryStatementBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryStatementBuilder.d.ts","sourceRoot":"","sources":["../../../src/helpers/QueryBuilders/QueryStatementBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,mBAAmB,EACnB,yBAAyB,EACzB,WAAW,EAEX,eAAe,EAClB,MAAM,sBAAsB,CAAC;AAY9B,MAAM,CAAC,OAAO,OAAO,qBAAqB;IACtC,OAAO,CAAC,OAAO,CAAc;IAC7B,OAAO,CAAC,SAAS,CAIV;IAEP,OAAO,CAAC,kBAAkB,CAA6C;IACvE,OAAO,CAAC,oBAAoB,CAA0B;gBAE1C,WAAW,EAAE,WAAW,EAAE,sBAAsB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,EAAE,CAAC;IAQhF,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC;YAcvB,cAAc;YAyCd,gBAAgB;YAgDhB,eAAe;WAiBf,6BAA6B,CACvC,KAAK,EAAE,mBAAmB,EAC1B,SAAS,EAAE,MAAM,EACjB,kBAAkB,GAAE,MAAM,EAAO,EACjC,mBAAmB,GAAE,GAAG,CAAC,MAAM,CAAa,GAC7C,yBAAyB,EAAE;WAqBhB,wBAAwB,CAClC,KAAK,EAAE,mBAAmB,GAC3B,yBAAyB,EAAE;IAa9B,OAAO,CAAC,SAAS;CAWpB"}

package/dist/helpers/QueryBuilders/QueryStatementBuilder.js

@@ -0,0 +1,169 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import BaseSelectQueryBuilder from "./BaseQueryBuilders/BaseSelectQueryBuilder.js";
+import ExpressionDecorator from "./QueryDecorators/ExpressionDecorator.js";
+import QueryExpressionBuilder from "./QueryExpressionBuilder.js";
+import WhereDecorator from "./QueryDecorators/WhereDecorator.js";
+import JoinDecorator from "./QueryDecorators/JoinDecorator.js";
+import GroupByDecorator from "./QueryDecorators/GroupByDecorator.js";
+import OrderByDecorator from "./QueryDecorators/OrderByDecorator.js";
+import LimitDecorator from "./QueryDecorators/LimitDecorator.js";
+import SqlRenderer from "./SqlRenderer.js";
+export default class QueryStatementBuilder {
+    constructor(queryLayers, tableColumnInformation) {
+        this._contexts = {};
+        this._tableColumnsCache = new Map();
+        this._valueClauseKeywords = new Set();
+        this._layers = queryLayers;
+        if (tableColumnInformation) {
+            this._tableColumnsCache = tableColumnInformation;
+        }
+    }
+    build() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let sql = yield this.buildBaseLayer();
+            if (this._layers.pretty) {
+                sql = yield this.buildPrettyLayer(sql);
+            }
+            if (this._layers.final) {
+                sql = yield this.buildFinalLayer(sql);
+            }
+            return sql;
+        });
+    }
+    buildBaseLayer() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            var _d, _e;
+            if (!this._layers.base.from) {
+                throw new Error("Base layer must specify 'from' table name.");
+            }
+            let builder = new BaseSelectQueryBuilder(this._layers.base.from, this._layers.base.select || [], this._layers.base.joinsSelect || [], this._layers.base.expressionsSelect || []);
+            if (this._layers.base.joins && this._layers.base.joins.length > 0) {
+                builder = new JoinDecorator(builder, { base: this._layers.base, pretty: this._layers.pretty, final: this._layers.final }, this._tableColumnsCache);
+            }
+            if (this._layers.base.expressions && this._layers.base.expressions.length > 0) {
+                const expressions = QueryExpressionBuilder.buildExpressionsPart(this._layers.base.expressions || []);
+                builder = new ExpressionDecorator(builder, expressions || []);
+                if (builder instanceof ExpressionDecorator) {
+                    this._valueClauseKeywords = new Set([...this._valueClauseKeywords, ...builder.valueClauseKeywords]);
+                    (_a = (_d = this._layers).pretty) !== null && _a !== void 0 ? _a : (_d.pretty = {});
+                    (_b = (_e = this._layers).final) !== null && _b !== void 0 ? _b : (_e.final = {});
+                    this._layers.pretty.where = this.addUnique(this._layers.pretty.where, builder.whereClauses);
+                    this._layers.pretty.groupBy = this.addUnique(this._layers.pretty.groupBy, builder.groupByClauses);
+                    this._layers.pretty.having = this.addUnique(this._layers.pretty.having, builder.havingClauses);
+                    this._layers.base.orderBy = this.addUnique((_c = this._layers.base.orderBy) === null || _c === void 0 ? void 0 : _c.map(ob => ({ column: `${ob.column}`, direction: ob.direction })), builder.orderByClauses);
+                }
+            }
+            if (this._layers.base.where) {
+                builder = new WhereDecorator(builder, this._layers.base.joins ? QueryStatementBuilder.normalizeAndQualifyConditions(this._layers.base.where, this._layers.base.from) : this._layers.base.where);
+            }
+            if (this._layers.base.orderBy) {
+                builder = new OrderByDecorator(builder, this._layers.base.orderBy);
+            }
+            this._contexts.base = yield builder.build();
+            const renderer = new SqlRenderer(this._contexts.base);
+            return renderer.build();
+        });
+    }
+    buildPrettyLayer(sql) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g;
+            var _h;
+            let builder = new BaseSelectQueryBuilder(`( ${sql} ) AS BASE_QUERY`, [...((_a = this._contexts.base) === null || _a === void 0 ? void 0 : _a.select) || [], ...((_b = this._layers.pretty) === null || _b === void 0 ? void 0 : _b.select) || []], ((_d = (_c = this._contexts.base) === null || _c === void 0 ? void 0 : _c.joinsSelect) === null || _d === void 0 ? void 0 : _d.map(j => j.split("AS")[1].trim())) || []);
+            if (this._layers.pretty) {
+                const expressions = ((_e = this._layers.pretty.expressions) === null || _e === void 0 ? void 0 : _e.length)
+                    ? QueryExpressionBuilder.buildExpressionsPart(this._layers.pretty.expressions)
+                    : [];
+                if (expressions.length > 0) {
+                    builder = new ExpressionDecorator(builder, expressions);
+                    if (builder instanceof ExpressionDecorator) {
+                        this._layers.pretty.where = this.addUnique(this._layers.pretty.where, builder.whereClauses);
+                        this._layers.pretty.groupBy = this.addUnique(this._layers.pretty.groupBy, builder.groupByClauses);
+                        this._layers.pretty.having = this.addUnique(this._layers.pretty.having, builder.havingClauses);
+                        (_f = (_h = this._layers).final) !== null && _f !== void 0 ? _f : (_h.final = {});
+                        this._layers.final.orderBy = this.addUnique((_g = this._layers.final.orderBy) === null || _g === void 0 ? void 0 : _g.map(ob => ({ column: `BASE_QUERY.${ob.column}`, direction: ob.direction })), builder.orderByClauses);
+                    }
+                    if (this._layers.pretty.where) {
+                        builder = new WhereDecorator(builder, QueryStatementBuilder.normalizeAndQualifyConditions(this._layers.pretty.where, "BASE_QUERY", [], this._valueClauseKeywords));
+                    }
+                }
+                else if (this._layers.pretty.where) {
+                    builder = new WhereDecorator(builder, QueryStatementBuilder.normalizeAndQualifyConditions(this._layers.pretty.where, "BASE_QUERY", [], this._valueClauseKeywords));
+                }
+                if (this._layers.pretty.groupBy) {
+                    builder = new GroupByDecorator(builder, this._layers.pretty.groupBy);
+                }
+                if (this._layers.pretty.having) {
+                    builder = new WhereDecorator(builder, QueryStatementBuilder.normalizeAndQualifyConditions(this._layers.pretty.having, "BASE_QUERY"));
+                }
+            }
+            this._contexts.pretty = yield builder.build();
+            const renderer = new SqlRenderer(this._contexts.pretty);
+            return renderer.build();
+        });
+    }
+    buildFinalLayer(sql) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            let builder = new BaseSelectQueryBuilder(`( ${sql} ) AS PRETTY_QUERY`, ((_a = this._layers.final) === null || _a === void 0 ? void 0 : _a.select) || []);
+            if (this._layers.final) {
+                if (this._layers.final.orderBy) {
+                    builder = new OrderByDecorator(builder, this._layers.final.orderBy);
+                }
+                if (this._layers.final.limit) {
+                    builder = new LimitDecorator(builder, this._layers.final.limit, this._layers.final.offset);
+                }
+            }
+            this._contexts.final = yield builder.build();
+            const renderer = new SqlRenderer(this._contexts.final);
+            return renderer.build();
+        });
+    }
+    static normalizeAndQualifyConditions(where, tableName, normalizeBlacklist = [], valueClauseKeywords = new Set()) {
+        const conditions = this.normalizeQueryConditions(where);
+        return conditions.map((condition) => {
+            const shouldSkipQualification = normalizeBlacklist.some((blk) => condition.column.includes(blk)) ||
+                condition.column.includes(".");
+            const isValueClauseKeyword = valueClauseKeywords.has(condition.column);
+            if (isValueClauseKeyword) {
+                return;
+            }
+            return Object.assign(Object.assign({}, condition), { column: shouldSkipQualification
+                    ? condition.column
+                    : `${tableName}.${condition.column}` });
+        }).filter(cond => cond !== undefined);
+    }
+    static normalizeQueryConditions(where) {
+        if (Array.isArray(where)) {
+            return where;
+        }
+        else {
+            return Object.entries(where).map(([column, value]) => ({
+                column,
+                operator: "=",
+                value,
+            }));
+        }
+    }
+    // Copilot moment maybe refactor this later
+    addUnique(target, values) {
+        if (!(values === null || values === void 0 ? void 0 : values.length))
+            return target !== null && target !== void 0 ? target : [];
+        const set = new Set((target !== null && target !== void 0 ? target : []).map(v => JSON.stringify(v)));
+        for (const v of values) {
+            const key = JSON.stringify(v);
+            if (!set.has(key))
+                set.add(key);
+        }
+        return Array.from(set).map(s => JSON.parse(s));
+    }
+    ;
+}

package/dist/helpers/QueryBuilders/SqlRenderer.d.ts

@@ -0,0 +1,15 @@
+import { QueryContext } from "../../types/query.js";
+export default class SqlRenderer {
+    private _context;
+    constructor(context: QueryContext);
+    build(): string;
+    private renderSelect;
+    private renderFrom;
+    private renderWhere;
+    private buildWhereWithOperators;
+    private renderOrderBy;
+    private renderGroupBy;
+    private renderLimit;
+    private renderOffset;
+}
+//# sourceMappingURL=SqlRenderer.d.ts.map

package/dist/helpers/QueryBuilders/SqlRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SqlRenderer.d.ts","sourceRoot":"","sources":["../../../src/helpers/QueryBuilders/SqlRenderer.ts"],"names":[],"mappings":"AAAA,OAAO,EAA6B,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAE/E,MAAM,CAAC,OAAO,OAAO,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAe;gBAEnB,OAAO,EAAE,YAAY;IAI1B,KAAK,IAAI,MAAM;IAatB,OAAO,CAAC,YAAY;IAapB,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,WAAW;IAWnB,OAAO,CAAC,uBAAuB;IAW/B,OAAO,CAAC,aAAa;IAYrB,OAAO,CAAC,aAAa;IAQrB,OAAO,CAAC,WAAW;IAQnB,OAAO,CAAC,YAAY;CAOvB"}

package/dist/helpers/QueryBuilders/SqlRenderer.js

@@ -0,0 +1,79 @@
+export default class SqlRenderer {
+    constructor(context) {
+        this._context = context;
+    }
+    build() {
+        var _a;
+        return [
+            this.renderSelect(),
+            this.renderFrom(),
+            (_a = this._context.joins) === null || _a === void 0 ? void 0 : _a.join(" "),
+            this.renderWhere(),
+            this.renderGroupBy(),
+            this.renderOrderBy(),
+            this.renderLimit(),
+            this.renderOffset()
+        ].map(e => e === null || e === void 0 ? void 0 : e.trim()).filter(e => e !== "").join(" ");
+    }
+    renderSelect() {
+        const selects = [];
+        if (this._context.select && this._context.select.length > 0) {
+            selects.push(...this._context.select);
+        }
+        else if (!this._context.joinsSelect || this._context.joinsSelect.length === 0) {
+            selects.push('*');
+        }
+        selects.push(...(this._context.joinsSelect || []));
+        selects.push(...(this._context.expressionSelect || []));
+        return selects.length > 0 ? `SELECT ${selects.join(", ")}` : "SELECT *";
+    }
+    renderFrom() {
+        return this._context.from ? `FROM ${this._context.from}` : "";
+    }
+    renderWhere() {
+        var _a;
+        if (!((_a = this._context.conditions) === null || _a === void 0 ? void 0 : _a.where) ||
+            Object.keys(this._context.conditions.where).length === 0) {
+            return "";
+        }
+        return `WHERE ${this.buildWhereWithOperators(this._context.conditions.where)}`;
+    }
+    buildWhereWithOperators(where) {
+        return where
+            .map((condition) => {
+            var _a;
+            const colName = condition.column.trim();
+            const paramName = colName.includes(".") ? (_a = colName.split(".").pop()) === null || _a === void 0 ? void 0 : _a.trim() : colName;
+            return `${colName} ${condition.operator} @${paramName}`;
+        })
+            .filter(Boolean)
+            .join(" AND ");
+    }
+    renderOrderBy() {
+        if (!this._context.orderBy || this._context.orderBy.length === 0) {
+            return "";
+        }
+        const orderByClauses = this._context.orderBy.map(ob => {
+            return `${ob.column} ${ob.direction}`;
+        });
+        return `ORDER BY ${orderByClauses.join(", ")}`;
+    }
+    renderGroupBy() {
+        if (!this._context.groupBy || this._context.groupBy.length === 0) {
+            return "";
+        }
+        return `GROUP BY ${this._context.groupBy.join(", ")}`;
+    }
+    renderLimit() {
+        if (!this._context.limit) {
+            return "";
+        }
+        return `LIMIT ${this._context.limit}`;
+    }
+    renderOffset() {
+        if (!this._context.offset) {
+            return "";
+        }
+        return `OFFSET ${this._context.offset}`;
+    }
+}

package/dist/helpers/QueryBuilders/oldQueryStatementBuilder.d.ts

@@ -0,0 +1,160 @@
+import { ExtraQueryParameters, QueryWhereCondition, QueryIsEqualParameter } from "../../types/index.js";
+/** Utility class for building SQL query strings */
+export default class oldQueryStatementBuilder {
+    /**
+     * Build an INSERT SQL statement with named parameter placeholders
+     *
+     * @param table - The table to insert into
+     * @param record - Object containing column names and their placeholder values
+     * @returns Complete INSERT SQL statement string with @fieldName placeholders
+     *
+     * @example
+     * ```typescript
+     * const query = QueryStatementBuilder.BuildInsert(usersTable, {
+     *   name: 'John',
+     *   email: 'john@example.com',
+     *   age: 30
+     * });
+     * // "INSERT INTO users (name, email, age) VALUES (@name, @email, @age)"
+     *
+     * // Note: The actual values will be bound separately using the Parameters object
+     * ```
+     */
+    static BuildInsert(tableName: string, record: QueryIsEqualParameter): string;
+    /**
+     * Build an UPDATE SQL statement with SET clause and WHERE conditions
+     *
+     * @param table - The table to update
+     * @param record - Object containing columns to update with their placeholder values
+     * @param where - Object containing WHERE conditions for targeting specific rows
+     * @returns Complete UPDATE SQL statement string with @fieldName placeholders
+     *
+     * @example
+     * ```typescript
+     * const query = QueryStatementBuilder.BuildUpdate(
+     *   usersTable,
+     *   { name: 'John Doe', age: 31 },
+     *   { id: 1 }
+     * );
+     * // "UPDATE users SET name = @name, age = @age WHERE id = @id"
+     *
+     * // Multiple WHERE conditions
+     * const query = QueryStatementBuilder.BuildUpdate(
+     *   usersTable,
+     *   { status: 'inactive' },
+     *   { status: 'active', last_login: '2023-01-01' }
+     * );
+     * // "UPDATE users SET status = @status WHERE status = @status AND last_login = @last_login"
+     * ```
+     */
+    static BuildUpdate(tableName: string, record: QueryWhereCondition, where: QueryWhereCondition): string;
+    /**
+     * Build a DELETE SQL statement with WHERE conditions
+     *
+     * @param table - The table to delete from
+     * @param where - Object containing WHERE conditions for targeting specific rows to delete
+     * @returns Complete DELETE SQL statement string with @fieldName placeholders
+     *
+     * @example
+     * ```typescript
+     * const query = QueryStatementBuilder.BuildDelete(usersTable, { id: 1 });
+     * // "DELETE FROM users WHERE id = @id"
+     *
+     * // Multiple WHERE conditions
+     * const query = QueryStatementBuilder.BuildDelete(usersTable, {
+     *   status: 'deleted',
+     *   last_login: '2020-01-01'
+     * });
+     * // "DELETE FROM users WHERE status = @status AND last_login = @last_login"
+     * ```
+     */
+    static BuildDelete(tableName: string, where: QueryWhereCondition): string;
+    /**
+     * Build a COUNT SQL statement to count rows, optionally with WHERE conditions
+     *
+     * @param table - The table to count rows from
+     * @param where - Optional object containing WHERE conditions to filter counted rows
+     * @returns Complete COUNT SQL statement string with @fieldName placeholders
+     *
+     * @example
+     * ```typescript
+     * // Count all rows
+     * const query = QueryStatementBuilder.BuildCount(usersTable);
+     * // "SELECT COUNT(*) as count FROM users"
+     *
+     * // Count with conditions
+     * const query = QueryStatementBuilder.BuildCount(usersTable, {
+     *   status: 'active',
+     *   age: 25
+     * });
+     * // "SELECT COUNT(*) as count FROM users WHERE status = @status AND age = @age"
+     * ```
+     */
+    static BuildCount(tableName: string, where?: QueryWhereCondition): string;
+    /**
+     * Build a WHERE clause from parameter conditions (helper method)
+     *
+     * Joins multiple conditions with AND operator.
+     * Returns empty string if no conditions are provided.
+     *
+     * @param where - Optional object containing WHERE conditions
+     * @returns WHERE clause string with @fieldName placeholders, or empty string if no conditions
+     *
+     * @example
+     * ```typescript
+     * // Single condition
+     * const whereClause = QueryStatementBuilder.BuildWhere({ id: 1 });
+     * // "WHERE id = @id"
+     *
+     * // Multiple conditions (joined with AND)
+     * const whereClause = QueryStatementBuilder.BuildWhere({
+     *   status: 'active',
+     *   age: 25,
+     *   role: 'admin'
+     * });
+     * // "WHERE status = @status AND age = @age AND role = @role"
+     *
+     * // No conditions
+     * const whereClause = QueryStatementBuilder.BuildWhere();
+     * // ""
+     * ```
+     */
+    static BuildWhere(where?: QueryWhereCondition): string;
+    private static buildWhereWithOperators;
+    private static buildWhereSimple;
+    /**
+     * Build query options clause (ORDER BY, LIMIT, OFFSET) (helper method)
+     *
+     * Processes query options and builds the corresponding SQL clauses.
+     * Returns empty string if no options are provided.
+     *
+     * @param options - Object containing orderBy, limit, and/or offset options
+     * @returns Query options clause as a string
+     *
+     * @example
+     * ```typescript
+     * // All options
+     * const optionsClause = QueryStatementBuilder.BuildQueryOptions({
+     *   orderBy: 'created_at DESC',
+     *   limit: 10,
+     *   offset: 20
+     * });
+     * // "ORDER BY created_at DESC LIMIT 10 OFFSET 20"
+     *
+     * // Just ordering
+     * const optionsClause = QueryStatementBuilder.BuildQueryOptions({
+     *   orderBy: 'name ASC'
+     * });
+     * // "ORDER BY name ASC"
+     *
+     * // Pagination only
+     * const optionsClause = QueryStatementBuilder.BuildQueryOptions({
+     *   limit: 25,
+     *   offset: 50
+     * });
+     * // "LIMIT 25 OFFSET 50"
+     * ```
+     */
+    static BuildQueryOptions(options: ExtraQueryParameters): string;
+}
+//# sourceMappingURL=oldQueryStatementBuilder.d.ts.map

package/dist/helpers/QueryBuilders/oldQueryStatementBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"oldQueryStatementBuilder.d.ts","sourceRoot":"","sources":["../../../src/helpers/QueryBuilders/oldQueryStatementBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,mBAAmB,EAA6B,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAEnI,mDAAmD;AACnD,MAAM,CAAC,OAAO,OAAO,wBAAwB;IACzC;;;;;;;;;;;;;;;;;;OAkBG;WACW,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,qBAAqB,GAAG,MAAM;IAYnF;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;WACW,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,mBAAmB,EAAE,KAAK,EAAE,mBAAmB,GAAG,MAAM;IAW7G;;;;;;;;;;;;;;;;;;;OAmBG;WACW,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,mBAAmB,GAAG,MAAM;IAShF;;;;;;;;;;;;;;;;;;;;OAoBG;WACW,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,mBAAmB,GAAG,MAAM;IAQhF;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;WACW,UAAU,CAAC,KAAK,CAAC,EAAE,mBAAmB,GAAG,MAAM;IAgB7D,OAAO,CAAC,MAAM,CAAC,uBAAuB;IAStC,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAK/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;WACW,iBAAiB,CAAC,OAAO,EAAE,oBAAoB,GAAG,MAAM;CAiBzE"}