drizzle-orm 0.10.21 → 0.10.24

package/dist/src/builders/lowLvlBuilders/create.d.ts

@@ -0,0 +1,12 @@
+import AbstractTable from '../../tables/abstractTable';
+export default class Create<TTable extends AbstractTable<TTable>> {
+    private tableBuilder;
+    private enumBuilder;
+    private columnsBuilder;
+    private primaryKey;
+    private uniqueKey;
+    private tableClass;
+    private constructor();
+    static table: <StaticTTable extends AbstractTable<StaticTTable>>(tableClass: AbstractTable<StaticTTable>) => Create<StaticTTable>;
+    build: () => string;
+}

package/dist/src/builders/lowLvlBuilders/create.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const column_1 = require("../../columns/column");
+const pgEnum_1 = __importDefault(require("../../columns/types/pgEnum"));
+const ecranate_1 = require("../../utils/ecranate");
+class Create {
+    constructor(tableClass) {
+        this.tableBuilder = [];
+        this.enumBuilder = [];
+        this.columnsBuilder = [];
+        this.primaryKey = [];
+        this.uniqueKey = [];
+        this.build = () => {
+            this.tableBuilder.push('CREATE TABLE IF NOT EXISTS ');
+            this.tableBuilder.push(this.tableClass.tableName());
+            this.tableBuilder.push(' (');
+            const tableValues = Object.values(this.tableClass);
+            const columns = tableValues.filter((value) => value instanceof column_1.Column);
+            for (let i = 0; i < columns.length; i += 1) {
+                const column = columns[i];
+                if (column instanceof column_1.Column) {
+                    const columnType = column.getColumnType();
+                    if (columnType instanceof pgEnum_1.default) {
+                        // eslint-disable-next-line new-cap
+                        const enumValues = Object.values(columnType.codeType);
+                        let resValue = '';
+                        for (let j = 0; j < enumValues.length; j += 1) {
+                            resValue += `'${enumValues[j]}'`;
+                            if (j !== enumValues.length - 1) {
+                                resValue += ',';
+                            }
+                        }
+                        this.enumBuilder.push(`DO $$ BEGIN
+          CREATE TYPE ${columnType.dbName} AS ENUM (${resValue});
+      EXCEPTION
+          WHEN duplicate_object THEN null;
+      END $$;`);
+                    }
+                    this.columnsBuilder.push(ecranate_1.ecranate(column.getColumnName()));
+                    this.columnsBuilder.push(' ');
+                    this.columnsBuilder.push(column.getColumnType().getDbName());
+                    this.columnsBuilder.push(' ');
+                    this.columnsBuilder.push(column.getDefaultValue() != null ? `DEFAULT ${column.getColumnType().insertStrategy(column.getDefaultValue())}` : '');
+                    this.columnsBuilder.push(column.isNullableFlag ? '' : ' NOT NULL');
+                    const referenced = column.getReferenced();
+                    this.columnsBuilder.push(referenced != null ? ` REFERENCES ${referenced.getParentName()} (${referenced.getColumnName()})` : '');
+                    if (i !== columns.length - 1) {
+                        this.columnsBuilder.push(',');
+                    }
+                }
+            }
+            const primaryKeys = [];
+            const uniqueKeys = [];
+            Object.values(this.tableClass).forEach((field) => {
+                if (field instanceof column_1.Column) {
+                    if (field.primaryKeyName) {
+                        primaryKeys.push(field);
+                    }
+                    if (field.uniqueKeyName) {
+                        uniqueKeys.push(field);
+                    }
+                }
+            });
+            if (primaryKeys.length !== 0) {
+                this.primaryKey.push(',');
+                this.primaryKey.push(`\nCONSTRAINT ${this.tableClass.tableName()}_${primaryKeys[0].getColumnName()}`);
+                this.primaryKey.push(' PRIMARY KEY(');
+                for (let i = 0; i < primaryKeys.length; i += 1) {
+                    const column = primaryKeys[i];
+                    this.primaryKey.push(column.getColumnName());
+                    if (i !== primaryKeys.length - 1) {
+                        this.primaryKey.push(',');
+                    }
+                }
+                this.primaryKey.push(')');
+            }
+            if (uniqueKeys.length !== 0) {
+                const columnName = uniqueKeys[0].getColumnName();
+                this.uniqueKey.push(',');
+                this.uniqueKey.push(`\nCONSTRAINT ${this.tableClass.tableName()}_${columnName}`);
+                this.uniqueKey.push(' UNIQUE(');
+                for (let i = 0; i < uniqueKeys.length; i += 1) {
+                    const column = uniqueKeys[i];
+                    this.uniqueKey.push(column.getColumnName());
+                    if (i !== uniqueKeys.length - 1) {
+                        this.uniqueKey.push(',');
+                    }
+                }
+                this.uniqueKey.push(')');
+            }
+            return `${this.enumBuilder.join('')} ${this.tableBuilder.join('') + this.columnsBuilder.join('') + this.primaryKey.join('') + this.uniqueKey.join('')});`;
+        };
+        this.tableClass = tableClass;
+    }
+}
+exports.default = Create;
+Create.table = (tableClass) => new Create(tableClass);

package/dist/src/builders/lowLvlBuilders/delets/delete.d.ts

@@ -0,0 +1,5 @@
+import { AbstractTable } from '../../../tables';
+import DeleteFrom from './deleteFrom';
+export default class Delete {
+    static from: <TTable extends AbstractTable<TTable>>(table: AbstractTable<TTable>) => DeleteFrom;
+}

package/dist/src/builders/lowLvlBuilders/delets/delete.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const deleteAggregator_1 = __importDefault(require("../../aggregators/deleteAggregator"));
+const deleteFrom_1 = __importDefault(require("./deleteFrom"));
+class Delete {
+}
+exports.default = Delete;
+Delete.from = (table) => {
+    const aggregator = new deleteAggregator_1.default(table);
+    aggregator.appendFrom(table.tableName());
+    return new deleteFrom_1.default(aggregator);
+};

package/dist/src/builders/lowLvlBuilders/delets/deleteFilter.d.ts

@@ -0,0 +1,11 @@
+import DeleteAggregator from '../../aggregators/deleteAggregator';
+import Expr from '../../requestBuilders/where/where';
+export default class DeleteFilter<SERVICE, DB> {
+    private _aggregator;
+    constructor(aggregator: DeleteAggregator);
+    apply: (filters: Expr) => DeleteFilter<SERVICE, DB>;
+    build: () => {
+        query: string;
+        values: any[];
+    };
+}

package/dist/src/builders/lowLvlBuilders/delets/deleteFilter.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class DeleteFilter {
+    constructor(aggregator) {
+        this.apply = (filters) => {
+            this._aggregator.filters(filters);
+            return this;
+        };
+        this.build = () => this._aggregator.buildQuery();
+        this._aggregator = aggregator;
+    }
+}
+exports.default = DeleteFilter;

package/dist/src/builders/lowLvlBuilders/delets/deleteFrom.d.ts

@@ -0,0 +1,12 @@
+import DeleteAggregator from '../../aggregators/deleteAggregator';
+import Expr from '../../requestBuilders/where/where';
+import DeleteFilter from './deleteFilter';
+export default class DeleteFrom {
+    private _aggregator;
+    constructor(aggregator: DeleteAggregator);
+    build: () => {
+        query: string;
+        values: any[];
+    };
+    filteredBy: (filters: Expr) => DeleteFilter<unknown, unknown>;
+}

package/dist/src/builders/lowLvlBuilders/delets/deleteFrom.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const deleteFilter_1 = __importDefault(require("./deleteFilter"));
+class DeleteFrom {
+    constructor(aggregator) {
+        this.build = () => this._aggregator.buildQuery();
+        this.filteredBy = (filters) => new deleteFilter_1.default(this._aggregator).apply(filters);
+        this._aggregator = aggregator;
+    }
+}
+exports.default = DeleteFrom;

package/dist/src/builders/lowLvlBuilders/inserts/insert.d.ts

@@ -0,0 +1,5 @@
+import { AbstractTable } from '../../../tables';
+import InsertInto from './insertInto';
+export default class Insert {
+    static into: <TTable extends AbstractTable<TTable>>(table: AbstractTable<TTable>) => InsertInto;
+}

package/dist/src/builders/lowLvlBuilders/inserts/insert.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const insertAggregator_1 = __importDefault(require("../../aggregators/insertAggregator"));
+const insertInto_1 = __importDefault(require("./insertInto"));
+class Insert {
+}
+exports.default = Insert;
+Insert.into = (table) => {
+    const aggregator = new insertAggregator_1.default(table);
+    // aggregator.appendFrom(table.tableName());
+    return new insertInto_1.default(aggregator);
+};

package/dist/src/builders/lowLvlBuilders/inserts/insertInto.d.ts

@@ -0,0 +1,13 @@
+import InsertAggregator from '../../aggregators/insertAggregator';
+import ValuesInsert from './valuesInsert';
+export default class InsertInto {
+    private _aggregator;
+    constructor(aggregator: InsertAggregator);
+    values: (values: {
+        [name: string]: any;
+    }[]) => ValuesInsert;
+    build: () => {
+        query: string;
+        values: any[];
+    };
+}

package/dist/src/builders/lowLvlBuilders/inserts/insertInto.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const valuesInsert_1 = __importDefault(require("./valuesInsert"));
+class InsertInto {
+    constructor(aggregator) {
+        // @TODO refactor!!
+        this.values = (values) => new valuesInsert_1.default(this._aggregator)
+            .apply(values);
+        this.build = () => this._aggregator.buildQuery();
+        this._aggregator = aggregator;
+    }
+}
+exports.default = InsertInto;

package/dist/src/builders/lowLvlBuilders/inserts/onConflictInsert.d.ts

@@ -0,0 +1,12 @@
+import { Indexing } from '../../../tables/inferTypes';
+import InsertAggregator from '../../aggregators/insertAggregator';
+import { UpdateExpr } from '../../requestBuilders/updates/updates';
+export default class OnConflictInsert {
+    private _aggregator;
+    constructor(aggregator: InsertAggregator);
+    apply: (updates: UpdateExpr, column: Indexing) => OnConflictInsert;
+    build: () => {
+        query: string;
+        values: any[];
+    };
+}

package/dist/src/builders/lowLvlBuilders/inserts/onConflictInsert.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class OnConflictInsert {
+    constructor(aggregator) {
+        this.apply = (updates, column) => {
+            this._aggregator.appendOnConflict(column, updates);
+            return this;
+        };
+        this.build = () => this._aggregator.buildQuery();
+        this._aggregator = aggregator;
+    }
+}
+exports.default = OnConflictInsert;

package/dist/src/builders/lowLvlBuilders/inserts/valuesInsert.d.ts

@@ -0,0 +1,16 @@
+import { Indexing } from '../../../tables/inferTypes';
+import InsertAggregator from '../../aggregators/insertAggregator';
+import { UpdateExpr } from '../../requestBuilders/updates/updates';
+import OnConflictInsert from './onConflictInsert';
+export default class ValuesInsert {
+    private _aggregator;
+    constructor(aggregator: InsertAggregator);
+    apply: (values: {
+        [name: string]: any;
+    }[]) => ValuesInsert;
+    onConflict: (updates: UpdateExpr, column: Indexing) => OnConflictInsert;
+    build: () => {
+        query: string;
+        values: any[];
+    };
+}

package/dist/src/builders/lowLvlBuilders/inserts/valuesInsert.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const onConflictInsert_1 = __importDefault(require("./onConflictInsert"));
+class ValuesInsert {
+    constructor(aggregator) {
+        this.apply = (values) => {
+            this._aggregator.appendColumns();
+            this._aggregator.appendValues(values);
+            return this;
+        };
+        this.onConflict = (updates, column) => new onConflictInsert_1.default(this._aggregator).apply(updates, column);
+        this.build = () => this._aggregator.buildQuery();
+        this._aggregator = aggregator;
+    }
+}
+exports.default = ValuesInsert;

package/dist/src/builders/lowLvlBuilders/selects/select.d.ts

@@ -0,0 +1,9 @@
+import { AbstractColumn } from '../../../columns/column';
+import ColumnType from '../../../columns/types/columnType';
+import { AbstractTable } from '../../../tables';
+import SelectFrom from './selectFrom';
+export default class Select {
+    static from: <TTable extends AbstractTable<TTable>, TType extends ColumnType<any>, TColumn extends AbstractColumn<TType, boolean, boolean, TTable>, T extends {
+        [name: string]: TColumn;
+    } = {}>(table: AbstractTable<TTable>, partial?: T | undefined) => SelectFrom;
+}

package/dist/src/builders/lowLvlBuilders/selects/select.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const selectAggregator_1 = __importDefault(require("../../aggregators/selectAggregator"));
+const selectFrom_1 = __importDefault(require("./selectFrom"));
+class Select {
+}
+exports.default = Select;
+// eslint-disable-next-line max-len
+Select.from = (table, partial) => {
+    const aggregator = new selectAggregator_1.default(table, partial);
+    aggregator.appendFrom(table.tableName());
+    return new selectFrom_1.default(aggregator);
+};

package/dist/src/builders/lowLvlBuilders/selects/selectFrom.d.ts

@@ -0,0 +1,28 @@
+import { AbstractColumn } from '../../../columns/column';
+import ColumnType from '../../../columns/types/columnType';
+import SelectAggregator from '../../aggregators/selectAggregator';
+import Order from '../../highLvlBuilders/order';
+import Join from '../../joinBuilders/join';
+import Expr from '../../requestBuilders/where/where';
+import SelectJoined from './selectJoined';
+import WhereSelect from './whereSelect';
+export default class SelectFrom {
+    private _aggregator;
+    constructor(aggregator: SelectAggregator);
+    joined: (joins: {
+        join: Join<any>;
+        partial?: {
+            [name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, any>;
+        } | undefined;
+        id?: number | undefined;
+    }[]) => SelectJoined;
+    limit: (limit?: number | undefined) => SelectFrom;
+    offset: (offset?: number | undefined) => SelectFrom;
+    orderBy: (orderBy?: AbstractColumn<ColumnType<{}>, boolean, boolean, any> | undefined, order?: Order | undefined) => SelectFrom;
+    distinct: (column?: AbstractColumn<ColumnType<{}>, boolean, boolean, any> | undefined) => SelectFrom;
+    filteredBy: (filters: Expr) => WhereSelect;
+    build: () => {
+        query: string;
+        values: any[];
+    };
+}

package/dist/src/builders/lowLvlBuilders/selects/selectFrom.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const selectJoined_1 = __importDefault(require("./selectJoined"));
+const whereSelect_1 = __importDefault(require("./whereSelect"));
+class SelectFrom {
+    constructor(aggregator) {
+        this.joined = (joins) => new selectJoined_1.default(this._aggregator).apply(joins);
+        this.limit = (limit) => {
+            this._aggregator.limit(limit);
+            return this;
+        };
+        this.offset = (offset) => {
+            this._aggregator.offset(offset);
+            return this;
+        };
+        this.orderBy = (orderBy, order) => {
+            this._aggregator.orderBy(orderBy, order);
+            return this;
+        };
+        this.distinct = (column) => {
+            if (column) {
+                this._aggregator.distinct(column);
+            }
+            return this;
+        };
+        this.filteredBy = (filters) => new whereSelect_1.default(this._aggregator).apply(filters);
+        this.build = () => this._aggregator.buildQuery();
+        this._aggregator = aggregator;
+    }
+}
+exports.default = SelectFrom;

package/dist/src/builders/lowLvlBuilders/selects/selectJoined.d.ts

@@ -0,0 +1,26 @@
+import { AbstractColumn } from '../../../columns/column';
+import ColumnType from '../../../columns/types/columnType';
+import SelectAggregator from '../../aggregators/selectAggregator';
+import Order from '../../highLvlBuilders/order';
+import Join from '../../joinBuilders/join';
+import Expr from '../../requestBuilders/where/where';
+import WhereSelect from './whereSelect';
+export default class SelectJoined {
+    private _aggregator;
+    constructor(aggregator: SelectAggregator);
+    apply: (joins: {
+        join: Join<any>;
+        partial?: {
+            [name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, any>;
+        } | undefined;
+        id?: number | undefined;
+    }[]) => SelectJoined;
+    limit: (limit?: number | undefined) => SelectJoined;
+    offset: (offset?: number | undefined) => SelectJoined;
+    orderBy: (orderBy?: AbstractColumn<ColumnType<{}>, boolean, boolean, any> | undefined, order?: Order | undefined) => SelectJoined;
+    filteredBy: (filters: Expr) => WhereSelect;
+    build: () => {
+        query: string;
+        values: any[];
+    };
+}

package/dist/src/builders/lowLvlBuilders/selects/selectJoined.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const whereSelect_1 = __importDefault(require("./whereSelect"));
+class SelectJoined {
+    constructor(aggregator) {
+        this.apply = (joins) => {
+            this._aggregator.join(joins);
+            return this;
+        };
+        this.limit = (limit) => {
+            this._aggregator.limit(limit);
+            return this;
+        };
+        this.offset = (offset) => {
+            this._aggregator.offset(offset);
+            return this;
+        };
+        this.orderBy = (orderBy, order) => {
+            this._aggregator.orderBy(orderBy, order);
+            return this;
+        };
+        this.filteredBy = (filters) => new whereSelect_1.default(this._aggregator).apply(filters);
+        this.build = () => this._aggregator.buildQuery();
+        this._aggregator = aggregator;
+    }
+}
+exports.default = SelectJoined;

package/dist/src/builders/lowLvlBuilders/selects/whereSelect.d.ts

@@ -0,0 +1,17 @@
+import { AbstractColumn } from '../../../columns/column';
+import ColumnType from '../../../columns/types/columnType';
+import SelectAggregator from '../../aggregators/selectAggregator';
+import Order from '../../highLvlBuilders/order';
+import Expr from '../../requestBuilders/where/where';
+export default class WhereSelect {
+    private _aggregator;
+    constructor(aggregator: SelectAggregator);
+    limit: (limit?: number | undefined) => WhereSelect;
+    offset: (offset?: number | undefined) => WhereSelect;
+    orderBy: (orderBy?: AbstractColumn<ColumnType<{}>, boolean, boolean, any> | undefined, order?: Order | undefined) => WhereSelect;
+    apply: (filters: Expr) => WhereSelect;
+    build: () => {
+        query: string;
+        values: any[];
+    };
+}

package/dist/src/builders/lowLvlBuilders/selects/whereSelect.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class WhereSelect {
+    constructor(aggregator) {
+        this.limit = (limit) => {
+            this._aggregator.limit(limit);
+            return this;
+        };
+        this.offset = (offset) => {
+            this._aggregator.offset(offset);
+            return this;
+        };
+        this.orderBy = (orderBy, order) => {
+            this._aggregator.orderBy(orderBy, order);
+            return this;
+        };
+        this.apply = (filters) => {
+            this._aggregator.filters(filters);
+            return this;
+        };
+        this.build = () => this._aggregator.buildQuery();
+        this._aggregator = aggregator;
+    }
+}
+exports.default = WhereSelect;

package/dist/src/builders/lowLvlBuilders/updates/update.d.ts

@@ -0,0 +1,5 @@
+import { AbstractTable } from '../../../tables';
+import UpdateIn from './updateIn';
+export default class Update {
+    static in: <TTable extends AbstractTable<TTable>>(table: AbstractTable<TTable>) => UpdateIn;
+}

package/dist/src/builders/lowLvlBuilders/updates/update.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const updateAggregator_1 = __importDefault(require("../../aggregators/updateAggregator"));
+const updateIn_1 = __importDefault(require("./updateIn"));
+class Update {
+}
+exports.default = Update;
+Update.in = (table) => {
+    const aggregator = new updateAggregator_1.default(table);
+    aggregator.appendFrom(table.tableName());
+    return new updateIn_1.default(aggregator);
+};

package/dist/src/builders/lowLvlBuilders/updates/updateIn.d.ts

@@ -0,0 +1,13 @@
+import UpdateAggregator from '../../aggregators/updateAggregator';
+import { UpdateExpr } from '../../requestBuilders/updates/updates';
+import WhereSet from './whereSet';
+export default class UpdateIn {
+    private _aggregator;
+    constructor(aggregator: UpdateAggregator);
+    columns: () => UpdateIn;
+    set: (updates: UpdateExpr) => WhereSet<unknown, unknown>;
+    build: () => {
+        query: string;
+        values: any[];
+    };
+}

package/dist/src/builders/lowLvlBuilders/updates/updateIn.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const whereSet_1 = __importDefault(require("./whereSet"));
+class UpdateIn {
+    constructor(aggregator) {
+        this.columns = () => new UpdateIn(this._aggregator);
+        this.set = (updates) => new whereSet_1.default(this._aggregator).apply(updates);
+        this.build = () => this._aggregator.buildQuery();
+        this._aggregator = aggregator;
+    }
+}
+exports.default = UpdateIn;

package/dist/src/builders/lowLvlBuilders/updates/whereSelect.d.ts

@@ -0,0 +1,11 @@
+import UpdateAggregator from '../../aggregators/updateAggregator';
+import Expr from '../../requestBuilders/where/where';
+export default class WhereSelect<SERVICE, DB> {
+    private _aggregator;
+    constructor(aggregator: UpdateAggregator);
+    apply: (filters: Expr) => WhereSelect<SERVICE, DB>;
+    build: () => {
+        query: string;
+        values: any[];
+    };
+}

package/dist/src/builders/lowLvlBuilders/updates/whereSelect.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class WhereSelect {
+    constructor(aggregator) {
+        this.apply = (filters) => {
+            this._aggregator.where(filters);
+            return this;
+        };
+        this.build = () => this._aggregator.buildQuery();
+        this._aggregator = aggregator;
+    }
+}
+exports.default = WhereSelect;

package/dist/src/builders/lowLvlBuilders/updates/whereSet.d.ts

@@ -0,0 +1,14 @@
+import UpdateAggregator from '../../aggregators/updateAggregator';
+import { UpdateExpr } from '../../requestBuilders/updates/updates';
+import Expr from '../../requestBuilders/where/where';
+import WhereSelect from './whereSelect';
+export default class WhereSet<SERVICE, DB> {
+    private _aggregator;
+    constructor(aggregator: UpdateAggregator);
+    apply: (updates: UpdateExpr) => WhereSet<SERVICE, DB>;
+    filteredBy: (filters: Expr) => WhereSelect<unknown, unknown>;
+    build: () => {
+        query: string;
+        values: any[];
+    };
+}

package/dist/src/builders/lowLvlBuilders/updates/whereSet.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const whereSelect_1 = __importDefault(require("./whereSelect"));
+class WhereSet {
+    constructor(aggregator) {
+        this.apply = (updates) => {
+            this._aggregator.set(updates);
+            return this;
+        };
+        this.filteredBy = (filters) => new whereSelect_1.default(this._aggregator).apply(filters);
+        this.build = () => this._aggregator.buildQuery();
+        this._aggregator = aggregator;
+    }
+}
+exports.default = WhereSet;

package/dist/src/builders/requestBuilders/updates/combine.d.ts

@@ -0,0 +1,9 @@
+import { UpdateExpr } from './updates';
+export default class Combine extends UpdateExpr {
+    private _setters;
+    constructor(setters: Array<UpdateExpr>);
+    toQuery: (position?: number | undefined) => {
+        query: string;
+        values: Array<any>;
+    };
+}