drizzle-orm 0.10.5 → 0.10.9

package/README.md

@@ -235,8 +235,8 @@ const ordered = await usersTable.select().orderBy((table) => table.phone, Order.
 #### **Partial Selecting**
  ```typescript
     const partialSelect = await usersTable.select({
-      id: usersTable.id,
-      phone: usersTable.phone,
+      mappedId: usersTable.id,
+      mappedPhone: usersTable.phone,
     }).all();
 
     // Usage
@@ -426,4 +426,14 @@ await drizzle.migrator(db).migrate('src/drizzle.config.yaml');
 ##### Another possibility is to provide object with path to folder with migrations
 ```typescript
 await drizzle.migrator(db).migrate({ migrationFolder: 'drizzle' });
+```
+
+
+## Raw query usage
+#### If you have some complex queries to execute and drizzle-orm can't handle them yet, then you could use `rawQuery` execution
+
+
+##### Execute custom raw query
+```typescript
+const res: QueryResult<any> = await db.session().execute('SELECT * FROM users WHERE user.id = $1', [1]);
 ```

package/builders/aggregators/deleteAggregator.d.ts

@@ -4,9 +4,13 @@ import Aggregator from './abstractAggregator';
 export default class DeleteAggregator extends Aggregator {
     private _from;
     private _filters;
+    private _values;
     private _delete;
     constructor(table: AbstractTable<any>);
     filters: (filters: Expr) => DeleteAggregator;
     appendFrom: (tableName: string) => DeleteAggregator;
-    buildQuery: () => string;
+    buildQuery: () => {
+        query: string;
+        values: Array<any>;
+    };
 }

package/builders/aggregators/deleteAggregator.js

@@ -6,11 +6,14 @@ class DeleteAggregator extends abstractAggregator_1.default {
         super(table);
         this._from = [];
         this._filters = [];
+        this._values = [];
         this._delete = ['DELETE'];
         this.filters = (filters) => {
             if (filters) {
+                const filterQuery = filters.toQuery();
                 this._filters.push('WHERE ');
-                this._filters.push(filters.toQuery());
+                this._filters.push(filterQuery.query);
+                this._values = filterQuery.values;
             }
             return this;
         };
@@ -29,7 +32,7 @@ class DeleteAggregator extends abstractAggregator_1.default {
             this._delete.push('RETURNING');
             this._delete.push('\n');
             this._delete.push(this._fields.join(''));
-            return this._delete.join('');
+            return { query: this._delete.join(''), values: this._values };
         };
     }
 }

package/builders/aggregators/insertAggregator.d.ts

@@ -5,6 +5,7 @@ import Aggregator from './abstractAggregator';
 export default class InsertAggregator extends Aggregator {
     private _onConflict;
     private _columns;
+    private _query;
     private _values;
     private _from;
     private _insert;
@@ -14,5 +15,8 @@ export default class InsertAggregator extends Aggregator {
         [name: string]: any;
     }[]) => void;
     appendOnConflict: (column: Indexing, updates?: UpdateExpr | undefined) => this;
-    buildQuery: () => string;
+    buildQuery: () => {
+        query: string;
+        values: Array<any>;
+    };
 }

package/builders/aggregators/insertAggregator.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-loop-func */
 const column_1 = require("../../columns/column");
 const abstractAggregator_1 = require("./abstractAggregator");
 class InsertAggregator extends abstractAggregator_1.default {
@@ -7,6 +8,7 @@ class InsertAggregator extends abstractAggregator_1.default {
         super(table);
         this._onConflict = [];
         this._columns = [];
+        this._query = [];
         this._values = [];
         this._from = [];
         this._insert = ['INSERT INTO'];
@@ -26,9 +28,10 @@ class InsertAggregator extends abstractAggregator_1.default {
         this.appendValues = (values) => {
             // @TODO Check if values not empty
             const mapper = this._table.mapServiceToDb();
+            let position = 0;
             for (let i = 0; i < values.length; i += 1) {
                 const value = values[i];
-                this._values.push('(');
+                this._query.push('(');
                 const entries = Object.entries(mapper);
                 entries.forEach(([key], index) => {
                     const valueToInsert = value[key];
@@ -36,24 +39,26 @@ class InsertAggregator extends abstractAggregator_1.default {
                     const column = mapper[key];
                     if (isKeyExistsInValue) {
                         if (valueToInsert !== undefined && valueToInsert !== null) {
+                            position += 1;
+                            this._query.push(`$${position}`);
                             this._values.push(column.getColumnType().insertStrategy(valueToInsert));
                         }
                         else {
-                            this._values.push('null');
+                            this._query.push('null');
                         }
                     }
                     else {
-                        this._values.push('DEFAULT');
+                        this._query.push('DEFAULT');
                     }
                     if (index < entries.length - 1) {
-                        this._values.push(', ');
+                        this._query.push(', ');
                     }
                 });
                 if (i < values.length - 1) {
-                    this._values.push('),\n');
+                    this._query.push('),\n');
                 }
                 else {
-                    this._values.push(')\n');
+                    this._query.push(')\n');
                 }
             }
         };
@@ -63,8 +68,12 @@ class InsertAggregator extends abstractAggregator_1.default {
                     ? column.getColumnName() : column.getColumns().map((it) => it.getColumnName()).join(',');
                 this._onConflict.push(`ON CONFLICT (${indexName})\n`);
                 if (updates) {
+                    const currentPointerPosition = this._values.length > 0
+                        ? this._values.length + 1 : undefined;
+                    const updatesQuery = updates.toQuery(currentPointerPosition);
                     this._onConflict.push('DO UPDATE\n');
-                    this._onConflict.push(`SET ${updates.toQuery()}`);
+                    this._onConflict.push(`SET ${updatesQuery.query}`);
+                    this._values.push(...updatesQuery.values);
                 }
                 else {
                     this._onConflict.push('DO NOTHING\n');
@@ -78,14 +87,14 @@ class InsertAggregator extends abstractAggregator_1.default {
             this._insert.push(this._columns.join(''));
             this._insert.push(') ');
             this._insert.push('VALUES\n');
-            this._insert.push(this._values.join(''));
+            this._insert.push(this._query.join(''));
             this._insert.push('\n');
             this._insert.push(this._onConflict.join(''));
             this._insert.push('\n');
             this._insert.push('RETURNING');
             this._insert.push('\n');
             this._insert.push(this._fields.join(''));
-            return this._insert.join('');
+            return { query: this._insert.join(''), values: this._values };
         };
         this._from.push(' ');
         this._from.push(table.tableName());

package/builders/aggregators/selectAggregator.d.ts

@@ -14,6 +14,8 @@ export default class SelectAggregator extends Aggregator {
     private _offset;
     private _distinct;
     private _orderBy;
+    private _values;
+    private _joinCache;
     constructor(table: AbstractTable<any>, partial?: {
         [name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, AbstractTable<any>>;
     });
@@ -30,5 +32,8 @@ export default class SelectAggregator extends Aggregator {
         } | undefined;
         id?: number | undefined;
     }[]) => SelectAggregator;
-    buildQuery: () => string;
+    buildQuery: () => {
+        query: string;
+        values: Array<any>;
+    };
 }

package/builders/aggregators/selectAggregator.js

@@ -17,10 +17,14 @@ class SelectAggregator extends abstractAggregator_1.default {
         this._distinct = [];
         // private _groupBy: Array<string> = [];
         this._orderBy = [];
+        this._values = [];
+        this._joinCache = {};
         this.filters = (filters) => {
             if (filters) {
+                const queryBuilder = filters.toQuery(1, this._joinCache);
                 this._filters.push('WHERE ');
-                this._filters.push(filters.toQuery());
+                this._filters.push(queryBuilder.query);
+                this._values = queryBuilder.values;
             }
             return this;
         };
@@ -59,7 +63,7 @@ class SelectAggregator extends abstractAggregator_1.default {
         };
         // Add select generator for second table also
         this.join = (joins) => {
-            const cache = {};
+            // const cache: {[tableName: string]: string} = {};
             joins.forEach((joinObject) => {
                 if (joinObject) {
                     const tableFrom = joinObject.join.fromColumn.getParentName();
@@ -82,12 +86,12 @@ class SelectAggregator extends abstractAggregator_1.default {
                     this._join.push(`AS ${tableTo}${joinObject.id ? `_${joinObject.id}` : ''}`);
                     this._join.push('\n');
                     this._join.push('ON ');
-                    if (cache[tableFrom]) {
-                        this._join.push(cache[tableFrom]);
+                    if (this._joinCache[tableFrom]) {
+                        this._join.push(this._joinCache[tableFrom]);
                     }
                     else {
                         this._join.push(tableFrom);
-                        cache[tableTo] = `${tableTo}${joinObject.id ? `_${joinObject.id}` : ''}`;
+                        this._joinCache[tableTo] = `${tableTo}${joinObject.id ? `_${joinObject.id}` : ''}`;
                     }
                     this._join.push('.');
                     this._join.push(joinObject.join.fromColumn.getColumnName());
@@ -116,7 +120,7 @@ class SelectAggregator extends abstractAggregator_1.default {
             this._select.push(this._limit.join(''));
             this._select.push('\n');
             this._select.push(this._offset.join(''));
-            return this._select.join('');
+            return { query: this._select.join(''), values: this._values };
         };
     }
 }

package/builders/aggregators/updateAggregator.d.ts

@@ -6,10 +6,14 @@ export default class UpdateAggregator extends Aggregator {
     private _updates;
     private _filters;
     private _from;
+    private _values;
     private _update;
     constructor(table: AbstractTable<any>);
     where: (filters: Expr) => UpdateAggregator;
     appendFrom: (tableName: string) => UpdateAggregator;
     set: (updates: UpdateExpr) => UpdateAggregator;
-    buildQuery: () => string;
+    buildQuery: () => {
+        query: string;
+        values: Array<any>;
+    };
 }

package/builders/aggregators/updateAggregator.js

@@ -7,11 +7,15 @@ class UpdateAggregator extends abstractAggregator_1.default {
         this._updates = [];
         this._filters = [];
         this._from = [];
+        this._values = [];
         this._update = ['UPDATE'];
         this.where = (filters) => {
             if (filters) {
+                const currentPointerPosition = this._values.length > 0 ? this._values.length + 1 : undefined;
+                const filterQuery = filters.toQuery(currentPointerPosition);
                 this._filters.push('WHERE ');
-                this._filters.push(filters.toQuery());
+                this._filters.push(filterQuery.query);
+                this._values.push(...filterQuery.values);
             }
             return this;
         };
@@ -21,7 +25,9 @@ class UpdateAggregator extends abstractAggregator_1.default {
             return this;
         };
         this.set = (updates) => {
-            this._updates.push(`\nSET ${updates.toQuery()}`);
+            const setQuery = updates.toQuery();
+            this._updates.push(`\nSET ${setQuery.query}`);
+            this._values.push(...setQuery.values);
             return this;
         };
         this.buildQuery = () => {
@@ -34,7 +40,7 @@ class UpdateAggregator extends abstractAggregator_1.default {
             this._update.push('RETURNING');
             this._update.push('\n');
             this._update.push(this._fields.join(''));
-            return this._update.join('');
+            return { query: this._update.join(''), values: this._values };
         };
     }
 }

package/builders/highLvlBuilders/deleteRequestBuilder.js

@@ -19,8 +19,11 @@ class DeleteTRB extends abstractRequestBuilder_1.default {
                 .from(this._table)
                 .filteredBy(this._filter);
             let query = '';
+            let values = [];
             try {
-                query = queryBuilder.build();
+                const builderResult = queryBuilder.build();
+                query = builderResult.query;
+                values = builderResult.values;
             }
             catch (e) {
                 throw new builderError_1.default(builderError_1.BuilderType.DELETE, this._table.tableName(), this._columns, e, this._filter);
@@ -28,7 +31,7 @@ class DeleteTRB extends abstractRequestBuilder_1.default {
             if (this._logger) {
                 this._logger.info(`Deleting from ${this._table.tableName()} using query:\n ${query}`);
             }
-            const result = await this._session.execute(query);
+            const result = await this._session.execute(query, values);
             return responseMapper_1.default.map(this._mappedServiceToDb, result);
         };
     }

package/builders/highLvlBuilders/insertRequestBuilder.js

@@ -30,8 +30,11 @@ class InsertTRB extends abstractRequestBuilder_1.default {
                 .values(this._values)
                 .onConflict(this._onConflict, this._onConflictField);
             let query = '';
+            let values = [];
             try {
-                query = queryBuilder.build();
+                const builderResult = queryBuilder.build();
+                query = builderResult.query;
+                values = builderResult.values;
             }
             catch (e) {
                 throw new builderError_1.default(builderError_1.BuilderType.INSERT, this._table.tableName(), this._columns, e);
@@ -39,7 +42,7 @@ class InsertTRB extends abstractRequestBuilder_1.default {
             if (this._logger) {
                 this._logger.info(`Inserting to ${this._table.tableName()} using query:\n ${query}`);
             }
-            const result = await this._session.execute(query);
+            const result = await this._session.execute(query, values);
             return responseMapper_1.default.map(this._mappedServiceToDb, result);
         };
         this._values = values;

package/builders/highLvlBuilders/selectRequestBuilder.js

@@ -39,16 +39,21 @@ class SelectTRB extends abstractRequestBuilder_1.default {
                 .offset(this.props.offset)
                 .orderBy(this.__orderBy, this.__order);
             let query = '';
+            let values = [];
             try {
-                query = queryBuilder.build();
+                const builderResult = queryBuilder.build();
+                query = builderResult.query;
+                values = builderResult.values;
             }
             catch (e) {
                 throw new builderError_1.default(builderError_1.BuilderType.SELECT, this._table.tableName(), this._columns, e, this._filter);
             }
+            console.log(query);
+            console.log(values);
             if (this._logger) {
                 this._logger.info(`Selecting from ${this._table.tableName()} using query:\n ${query}`);
             }
-            const result = await this._session.execute(query);
+            const result = await this._session.execute(query, values);
             if (this.__partial) {
                 return responseMapper_1.default.partialMap(this.__partial, result);
             }

package/builders/highLvlBuilders/updateRequestBuilder.js

@@ -33,20 +33,24 @@ class UpdateTRB extends abstractRequestBuilder_1.default {
         };
         this._execute = async () => {
             let query = '';
+            let values = [];
             try {
-                query = update_1.default.in(this._table)
+                const builderResult = update_1.default.in(this._table)
                     .columns()
                     .set(this._update)
                     .filteredBy(this._filter)
                     .build();
+                query = builderResult.query;
+                values = builderResult.values;
             }
             catch (e) {
                 throw new builderError_1.default(builderError_1.BuilderType.UPDATE, this._table.tableName(), this._columns, e, this._filter);
             }
             if (this._logger) {
                 this._logger.info(`Updating ${this._table.tableName()} using query:\n ${query}`);
+                console.log(values);
             }
-            const result = await this._session.execute(query);
+            const result = await this._session.execute(query, values);
             return responseMapper_1.default.map(this._mappedServiceToDb, result);
         };
     }

package/builders/joinBuilders/builders/abstractJoinBuilder.js

@@ -23,14 +23,18 @@ class AbstractJoined {
                 .filteredBy(this._filter)
                 .orderBy(this._orderBy, this._order);
             let query = '';
+            let values = [];
             try {
-                query = queryBuilder.build();
-                console.log(query);
+                const builderResult = queryBuilder.build();
+                query = builderResult.query;
+                values = builderResult.values;
             }
             catch (e) {
                 throw new builderError_1.default(builderError_1.BuilderType.JOINED_SELECT, this._table.tableName(), Object.values(this._table.mapServiceToDb()), e, this._filter);
             }
-            const result = await this._session.execute(query);
+            console.log(query);
+            console.log(values);
+            const result = await this._session.execute(query, values);
             return this.mapResponse(result);
         };
         this._table = table;

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

@@ -4,5 +4,8 @@ export default class DeleteFilter<SERVICE, DB> {
     private _aggregator;
     constructor(aggregator: DeleteAggregator);
     apply: (filters: Expr) => DeleteFilter<SERVICE, DB>;
-    build: () => string;
+    build: () => {
+        query: string;
+        values: any[];
+    };
 }

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

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

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

@@ -6,5 +6,8 @@ export default class InsertInto {
     values: (values: {
         [name: string]: any;
     }[]) => ValuesInsert;
-    build: () => string;
+    build: () => {
+        query: string;
+        values: any[];
+    };
 }

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

@@ -5,5 +5,8 @@ export default class OnConflictInsert {
     private _aggregator;
     constructor(aggregator: InsertAggregator);
     apply: (updates: UpdateExpr, column: Indexing) => OnConflictInsert;
-    build: () => string;
+    build: () => {
+        query: string;
+        values: any[];
+    };
 }

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

@@ -9,5 +9,8 @@ export default class ValuesInsert {
         [name: string]: any;
     }[]) => ValuesInsert;
     onConflict: (updates: UpdateExpr, column: Indexing) => OnConflictInsert;
-    build: () => string;
+    build: () => {
+        query: string;
+        values: any[];
+    };
 }

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

@@ -21,5 +21,8 @@ export default class 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: () => string;
+    build: () => {
+        query: string;
+        values: any[];
+    };
 }

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

@@ -19,5 +19,8 @@ export default class SelectJoined {
     offset: (offset?: number | undefined) => SelectJoined;
     orderBy: (orderBy?: AbstractColumn<ColumnType<{}>, boolean, boolean, any> | undefined, order?: Order | undefined) => SelectJoined;
     filteredBy: (filters: Expr) => WhereSelect;
-    build: () => string;
+    build: () => {
+        query: string;
+        values: any[];
+    };
 }

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

@@ -10,5 +10,8 @@ export default class WhereSelect {
     offset: (offset?: number | undefined) => WhereSelect;
     orderBy: (orderBy?: AbstractColumn<ColumnType<{}>, boolean, boolean, any> | undefined, order?: Order | undefined) => WhereSelect;
     apply: (filters: Expr) => WhereSelect;
-    build: () => string;
+    build: () => {
+        query: string;
+        values: any[];
+    };
 }

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

@@ -6,5 +6,8 @@ export default class UpdateIn {
     constructor(aggregator: UpdateAggregator);
     columns: () => UpdateIn;
     set: (updates: UpdateExpr) => WhereSet<unknown, unknown>;
-    build: () => string;
+    build: () => {
+        query: string;
+        values: any[];
+    };
 }

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

@@ -4,5 +4,8 @@ export default class WhereSelect<SERVICE, DB> {
     private _aggregator;
     constructor(aggregator: UpdateAggregator);
     apply: (filters: Expr) => WhereSelect<SERVICE, DB>;
-    build: () => string;
+    build: () => {
+        query: string;
+        values: any[];
+    };
 }

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

@@ -7,5 +7,8 @@ export default class WhereSet<SERVICE, DB> {
     constructor(aggregator: UpdateAggregator);
     apply: (updates: UpdateExpr) => WhereSet<SERVICE, DB>;
     filteredBy: (filters: Expr) => WhereSelect<unknown, unknown>;
-    build: () => string;
+    build: () => {
+        query: string;
+        values: any[];
+    };
 }

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

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

package/builders/requestBuilders/updates/combine.js

@@ -4,16 +4,21 @@ const updates_1 = require("./updates");
 class Combine extends updates_1.UpdateExpr {
     constructor(setters) {
         super();
-        this.toQuery = () => {
+        this.toQuery = (position) => {
+            let nextPosition = position || 1;
             const response = [];
+            const valuesResult = [];
             for (let index = 0; index < this._setters.length; index += 1) {
                 const setter = this._setters[index];
-                response.push(setter.toQuery());
+                const expressionResult = setter.toQuery(nextPosition);
+                valuesResult.push(...expressionResult.values);
+                response.push(expressionResult.query);
+                nextPosition += expressionResult.values.length;
                 if (index !== this._setters.length - 1) {
                     response.push(', ');
                 }
             }
-            return response.join('');
+            return { query: response.join(''), values: valuesResult };
         };
         this._setters = setters;
     }

package/builders/requestBuilders/updates/increment.d.ts

@@ -6,5 +6,8 @@ export default class Increment<T extends AbstractColumn<ColumnType<any>, boolean
     private _value;
     constructor(value: number);
     setColumn: (column: T) => UpdateCustomExpr<T>;
-    toQuery: () => string;
+    toQuery: () => {
+        query: string;
+        values: Array<any>;
+    };
 }

package/builders/requestBuilders/updates/increment.js

@@ -8,7 +8,10 @@ class Increment extends updates_1.UpdateCustomExpr {
             this._column = column;
             return this;
         };
-        this.toQuery = () => `${this._column.getColumnName()} = ${this._column.getColumnName()} + ${this._value}`;
+        this.toQuery = () => {
+            const query = `${this._column.getColumnName()} = ${this._column.getColumnName()} + ${this._value}`;
+            return { query, values: [] };
+        };
         this._value = value;
     }
 }

package/builders/requestBuilders/updates/setObjects.d.ts

@@ -5,5 +5,8 @@ export default class SetObject<T extends AbstractColumn<ColumnType<any>, boolean
     private _column;
     private _value;
     constructor(column: T, value: any);
-    toQuery: () => string;
+    toQuery: (position?: number | undefined) => {
+        query: string;
+        values: Array<any>;
+    };
 }

package/builders/requestBuilders/updates/setObjects.js

@@ -4,7 +4,11 @@ const updates_1 = require("./updates");
 class SetObject extends updates_1.UpdateExpr {
     constructor(column, value) {
         super();
-        this.toQuery = () => `"${this._column.getColumnName()}"=${this._value === null || this._value === undefined ? 'null' : this._column.getColumnType().insertStrategy(this._value)}`;
+        this.toQuery = (position) => {
+            const nextPosition = position || 1;
+            const query = `"${this._column.getColumnName()}"=${this._value === null || this._value === undefined ? 'null' : `$${nextPosition}`}`;
+            return { query, values: [this._column.getColumnType().insertStrategy(this._value)] };
+        };
         this._column = column;
         this._value = value;
     }

package/builders/requestBuilders/updates/updates.d.ts

@@ -1,5 +1,8 @@
 export declare abstract class UpdateExpr {
-    abstract toQuery(): string;
+    abstract toQuery(position?: number): {
+        query: string;
+        values: Array<any>;
+    };
 }
 export declare abstract class UpdateCustomExpr<T> extends UpdateExpr {
     abstract setColumn(column: T): UpdateCustomExpr<T>;

package/builders/requestBuilders/where/and.d.ts

@@ -2,5 +2,10 @@ import Expr from './where';
 export default class And extends Expr {
     private expressions;
     constructor(expressions: Expr[]);
-    toQuery: () => string;
+    toQuery: (position?: number | undefined, tableCache?: {
+        [tableName: string]: string;
+    } | undefined) => {
+        query: string;
+        values: Array<any>;
+    };
 }