@iamkirbki/database-handler-core 4.3.1 → 4.4.0

package/dist/helpers/QueryBuilders/QueryDecorators/JoinDecorator.js

@@ -0,0 +1,74 @@
+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 QueryDecorator from "./QueryDecorator.js";
+export default class JoinDecorator extends QueryDecorator {
+    constructor(builder, layer, tableColumnInformation) {
+        var _a, _b, _c, _d, _e;
+        if (!layer.base.from) {
+            throw new Error("Base layer must specify 'from' table name for JoinDecorator.");
+        }
+        super(builder);
+        this.fromTableName = layer.base.from;
+        this.joins = layer.base.joins || [];
+        this.tableColumnsCache = tableColumnInformation;
+        this.options = {
+            orderBy: (_a = layer.final) === null || _a === void 0 ? void 0 : _a.orderBy,
+            limit: (_b = layer.final) === null || _b === void 0 ? void 0 : _b.limit,
+            offset: (_c = layer.final) === null || _c === void 0 ? void 0 : _c.offset,
+            groupBy: (_d = layer.pretty) === null || _d === void 0 ? void 0 : _d.groupBy,
+            blacklistTables: (_e = layer.final) === null || _e === void 0 ? void 0 : _e.blacklistTables,
+        };
+    }
+    build() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const context = yield this.component.build();
+            const selectExtensions = yield this.buildJoinSelect();
+            const joinPart = this.buildJoinPart();
+            context.joinsSelect = selectExtensions;
+            (_a = context.joins) !== null && _a !== void 0 ? _a : (context.joins = []);
+            context.joins.push(...joinPart);
+            return context;
+        });
+    }
+    buildJoinSelect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const blacklist = ((_a = this.options) === null || _a === void 0 ? void 0 : _a.blacklistTables) || [];
+            const joinArray = Array.isArray(this.joins) ? this.joins : [this.joins];
+            const mainCols = this.tableColumnsCache.get(this.fromTableName) || [];
+            const mainSelect = mainCols
+                .filter(() => !blacklist.includes(this.fromTableName))
+                .map(col => `"${this.fromTableName}"."${col.name}" AS "${this.fromTableName}__${col.name}"`);
+            const joinedSelects = yield Promise.all(joinArray.map((join) => __awaiter(this, void 0, void 0, function* () {
+                if (blacklist.includes(join.fromTable))
+                    return "";
+                const cols = this.tableColumnsCache.get(join.fromTable) || [];
+                return cols
+                    .map(col => `"${join.fromTable}"."${col.name}" AS "${join.fromTable}__${col.name}"`)
+                    .filter(col => col.trim() !== "");
+            })));
+            return [...mainSelect, ...joinedSelects.flat()].filter(s => s !== "").filter(Boolean);
+        });
+    }
+    buildJoinPart() {
+        const joinArray = Array.isArray(this.joins) ? this.joins : [this.joins];
+        return joinArray.map(join => {
+            const baseTable = join.baseTable || this.fromTableName;
+            const onConditions = Array.isArray(join.on) ? join.on : [join.on];
+            const onClause = onConditions.map(part => {
+                const targetCol = Object.keys(part)[0];
+                const sourceCol = Object.values(part)[0];
+                return `${baseTable}.${sourceCol} = ${join.fromTable}.${targetCol}`;
+            }).join(" AND ");
+            return `${join.joinType} JOIN "${join.fromTable}" ON ${onClause}`;
+        });
+    }
+}

package/dist/helpers/QueryBuilders/QueryDecorators/LimitDecorator.d.ts

@@ -0,0 +1,10 @@
+import IQueryBuilder from "../../../interfaces/IQueryBuilder.js";
+import QueryDecorator from "./QueryDecorator.js";
+import { QueryContext } from "../../../types/query.js";
+export default class LimitDecorator extends QueryDecorator {
+    private limitCount;
+    private offsetCount?;
+    constructor(component: IQueryBuilder, limitCount: number, offsetCount?: number);
+    build(): Promise<QueryContext>;
+}
+//# sourceMappingURL=LimitDecorator.d.ts.map

package/dist/helpers/QueryBuilders/QueryDecorators/LimitDecorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LimitDecorator.d.ts","sourceRoot":"","sources":["../../../../src/helpers/QueryBuilders/QueryDecorators/LimitDecorator.ts"],"names":[],"mappings":"AAAA,OAAO,aAAa,MAAM,mCAAmC,CAAC;AAC9D,OAAO,cAAc,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEpD,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,cAAc;IACtD,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,WAAW,CAAC,CAAS;gBAEjB,SAAS,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM;IAMxE,KAAK,IAAI,OAAO,CAAC,YAAY,CAAC;CAYvC"}

package/dist/helpers/QueryBuilders/QueryDecorators/LimitDecorator.js

@@ -0,0 +1,29 @@
+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 QueryDecorator from "./QueryDecorator.js";
+export default class LimitDecorator extends QueryDecorator {
+    constructor(component, limitCount, offsetCount) {
+        super(component);
+        this.limitCount = limitCount;
+        this.offsetCount = offsetCount;
+    }
+    build() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const context = yield this.component.build();
+            if (this.limitCount) {
+                context.limit = this.limitCount;
+            }
+            if (this.offsetCount) {
+                context.offset = this.offsetCount;
+            }
+            return context;
+        });
+    }
+}

package/dist/helpers/QueryBuilders/QueryDecorators/OrderByDecorator.d.ts

@@ -0,0 +1,9 @@
+import IQueryBuilder from "../../../interfaces/IQueryBuilder.js";
+import QueryDecorator from "./QueryDecorator.js";
+import { OrderByDefinition, QueryContext } from "../../../types/query.js";
+export default class OrderByDecorator extends QueryDecorator {
+    private orderByColumns?;
+    constructor(component: IQueryBuilder, orderByColumns?: OrderByDefinition[]);
+    build(): Promise<QueryContext>;
+}
+//# sourceMappingURL=OrderByDecorator.d.ts.map

package/dist/helpers/QueryBuilders/QueryDecorators/OrderByDecorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OrderByDecorator.d.ts","sourceRoot":"","sources":["../../../../src/helpers/QueryBuilders/QueryDecorators/OrderByDecorator.ts"],"names":[],"mappings":"AAAA,OAAO,aAAa,MAAM,mCAAmC,CAAC;AAC9D,OAAO,cAAc,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEvE,MAAM,CAAC,OAAO,OAAO,gBAAiB,SAAQ,cAAc;IACxD,OAAO,CAAC,cAAc,CAAC,CAAsB;gBAEjC,SAAS,EAAE,aAAa,EAAE,cAAc,CAAC,EAAE,iBAAiB,EAAE;IAKpE,KAAK,IAAI,OAAO,CAAC,YAAY,CAAC;CASvC"}

package/dist/helpers/QueryBuilders/QueryDecorators/OrderByDecorator.js

@@ -0,0 +1,27 @@
+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 QueryDecorator from "./QueryDecorator.js";
+export default class OrderByDecorator extends QueryDecorator {
+    constructor(component, orderByColumns) {
+        super(component);
+        this.orderByColumns = orderByColumns;
+    }
+    build() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const context = yield this.component.build();
+            if (this.orderByColumns) {
+                (_a = context.orderBy) !== null && _a !== void 0 ? _a : (context.orderBy = []);
+                context.orderBy.push(...this.orderByColumns);
+            }
+            return context;
+        });
+    }
+}

package/dist/helpers/QueryBuilders/QueryDecorators/QueryDecorator.d.ts

@@ -0,0 +1,8 @@
+import IQueryBuilder from "../../../interfaces/IQueryBuilder";
+import { QueryContext } from "../../../types/query";
+export default abstract class QueryDecorator implements IQueryBuilder {
+    protected component: IQueryBuilder;
+    constructor(component: IQueryBuilder);
+    abstract build(): Promise<QueryContext>;
+}
+//# sourceMappingURL=QueryDecorator.d.ts.map

package/dist/helpers/QueryBuilders/QueryDecorators/QueryDecorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryDecorator.d.ts","sourceRoot":"","sources":["../../../../src/helpers/QueryBuilders/QueryDecorators/QueryDecorator.ts"],"names":[],"mappings":"AAAA,OAAO,aAAa,MAAM,gCAAgC,CAAC;AAC3D,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEjD,MAAM,CAAC,OAAO,CAAC,QAAQ,OAAO,cAAe,YAAW,aAAa;IACjE,SAAS,CAAC,SAAS,EAAE,aAAa,CAAC;gBAEvB,SAAS,EAAE,aAAa;IAIpC,QAAQ,CAAC,KAAK,IAAI,OAAO,CAAC,YAAY,CAAC;CAC1C"}

package/dist/helpers/QueryBuilders/QueryDecorators/QueryDecorator.js

@@ -0,0 +1,5 @@
+export default class QueryDecorator {
+    constructor(component) {
+        this.component = component;
+    }
+}

package/dist/helpers/QueryBuilders/QueryDecorators/ValuesDecorator.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=ValuesDecorator.d.ts.map

package/dist/helpers/QueryBuilders/QueryDecorators/ValuesDecorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ValuesDecorator.d.ts","sourceRoot":"","sources":["../../../../src/helpers/QueryBuilders/QueryDecorators/ValuesDecorator.ts"],"names":[],"mappings":""}

package/dist/helpers/QueryBuilders/QueryDecorators/ValuesDecorator.js

@@ -0,0 +1,17 @@
+"use strict";
+// import IQueryBuilder from "../../../interfaces/IQueryBuilder.js";
+// import { columnType } from "../../../types/index.js";
+// import QueryDecorator from "./QueryDecorator";
+// export default class ValuesDecorator extends QueryDecorator {
+//     private values: columnType[];
+//     constructor(component: IQueryBuilder, values: columnType[]) {
+//         super(component);
+//         this.values = values;
+//     }
+//     async build(): Promise<string> {
+//         const baseQuery = await this.component.build();
+//         const columns = Object.keys(this.values);
+//         const placeholders = columns.map((col) => `@${col}`);
+//         return `${baseQuery} ${columns.map((c) => `"${c}"`).join(", ")} VALUES (${placeholders.join(", ")})`;
+//     }
+// }

package/dist/helpers/QueryBuilders/QueryDecorators/WhereDecorator.d.ts

@@ -0,0 +1,9 @@
+import IQueryBuilder from "../../../interfaces/IQueryBuilder.js";
+import { QueryContext, QueryWhereCondition } from "../../../types/query.js";
+import QueryDecorator from "./QueryDecorator.js";
+export default class WhereDecorator extends QueryDecorator {
+    private conditions;
+    constructor(component: IQueryBuilder, conditions: QueryWhereCondition);
+    build(): Promise<QueryContext>;
+}
+//# sourceMappingURL=WhereDecorator.d.ts.map

package/dist/helpers/QueryBuilders/QueryDecorators/WhereDecorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WhereDecorator.d.ts","sourceRoot":"","sources":["../../../../src/helpers/QueryBuilders/QueryDecorators/WhereDecorator.ts"],"names":[],"mappings":"AAAA,OAAO,aAAa,MAAM,mCAAmC,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AACzE,OAAO,cAAc,MAAM,qBAAqB,CAAC;AAGjD,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,cAAc;IACtD,OAAO,CAAC,UAAU,CAAsB;gBAGpC,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,mBAAmB;IAM7B,KAAK,IAAI,OAAO,CAAC,YAAY,CAAC;CAUvC"}

package/dist/helpers/QueryBuilders/QueryDecorators/WhereDecorator.js

@@ -0,0 +1,29 @@
+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 QueryDecorator from "./QueryDecorator.js";
+import QueryStatementBuilder from "../QueryStatementBuilder.js";
+export default class WhereDecorator extends QueryDecorator {
+    constructor(component, conditions) {
+        super(component);
+        this.conditions = conditions;
+    }
+    build() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            var _c;
+            const context = yield this.component.build();
+            const combinedConditions = [...QueryStatementBuilder.normalizeQueryConditions(this.conditions)];
+            (_a = context.conditions) !== null && _a !== void 0 ? _a : (context.conditions = {});
+            (_b = (_c = context.conditions).where) !== null && _b !== void 0 ? _b : (_c.where = []);
+            context.conditions.where.push(...combinedConditions);
+            return context;
+        });
+    }
+}

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

@@ -0,0 +1,54 @@
+import { PossibleExpressions, ExpressionBuilderFunction, expressionClause } from "../../types/index.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.
+ */
+export default class QueryExpressionBuilder {
+    /**
+     * Registry mapping expression "type" → builder function.
+     *
+     * This allows:
+     * - zero switch statements
+     * - easy plugin-style extension
+     * - no touching core logic to add new expressions
+     */
+    private static expressionBuilders;
+    private static expressionDefaults;
+    static getExpressionDefaultRequirements(type: string): PossibleExpressions['requirements'] | undefined;
+    /**
+     * 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<T extends PossibleExpressions>(type: string, builder: ExpressionBuilderFunction<T>): void;
+    /**
+     * 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: PossibleExpressions[]): expressionClause[];
+}
+//# sourceMappingURL=QueryExpressionBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"QueryExpressionBuilder.d.ts","sourceRoot":"","sources":["../../../src/helpers/QueryBuilders/QueryExpressionBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,mBAAmB,EAEnB,yBAAyB,EACzB,gBAAgB,EAGnB,MAAM,sBAAsB,CAAC;AAM9B;;;;;;;;;;GAUG;AAEH;;;;;;;;;;GAUG;AACH,MAAM,CAAC,OAAO,OAAO,sBAAsB;IAEvC;;;;;;;OAOG;IACH,OAAO,CAAC,MAAM,CAAC,kBAAkB,CA0B9B;IAEH,OAAO,CAAC,MAAM,CAAC,kBAAkB,CAa9B;WAEW,gCAAgC,CAC1C,IAAI,EAAE,MAAM,GACb,mBAAmB,CAAC,cAAc,CAAC,GAAG,SAAS;IAIlD;;;;;;;;OAQG;WACW,yBAAyB,CAAC,CAAC,SAAS,mBAAmB,EACjE,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,yBAAyB,CAAC,CAAC,CAAC,GACtC,IAAI;IAIP;;;;;OAKG;WACW,oBAAoB,CAC9B,WAAW,EAAE,mBAAmB,EAAE,GACnC,gBAAgB,EAAE;CAexB"}

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"}