drizzle-orm 0.10.21 → 0.10.24

package/dist/src/builders/requestBuilders/updates/combine.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const updates_1 = require("./updates");
+class Combine extends updates_1.UpdateExpr {
+    constructor(setters) {
+        super();
+        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];
+                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 { query: response.join(''), values: valuesResult };
+        };
+        this._setters = setters;
+    }
+}
+exports.default = Combine;

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

@@ -0,0 +1,13 @@
+import { AbstractColumn } from '../../../columns/column';
+import ColumnType from '../../../columns/types/columnType';
+import { UpdateCustomExpr } from './updates';
+export default class Increment<T extends AbstractColumn<ColumnType<any>, boolean, boolean>> extends UpdateCustomExpr<T> {
+    private _column;
+    private _value;
+    constructor(value: number);
+    setColumn: (column: T) => UpdateCustomExpr<T>;
+    toQuery: () => {
+        query: string;
+        values: Array<any>;
+    };
+}

package/dist/src/builders/requestBuilders/updates/increment.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const updates_1 = require("./updates");
+class Increment extends updates_1.UpdateCustomExpr {
+    constructor(value) {
+        super();
+        this.setColumn = (column) => {
+            this._column = column;
+            return this;
+        };
+        this.toQuery = () => {
+            const query = `${this._column.getColumnName()} = ${this._column.getColumnName()} + ${this._value}`;
+            return { query, values: [] };
+        };
+        this._value = value;
+    }
+}
+exports.default = Increment;

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

@@ -0,0 +1,12 @@
+import { AbstractColumn } from '../../../columns/column';
+import ColumnType from '../../../columns/types/columnType';
+import { UpdateExpr } from './updates';
+export default class SetObject<T extends AbstractColumn<ColumnType<any>, boolean, boolean>> extends UpdateExpr {
+    private _column;
+    private _value;
+    constructor(column: T, value: any);
+    toQuery: (position?: number | undefined) => {
+        query: string;
+        values: Array<any>;
+    };
+}

package/dist/src/builders/requestBuilders/updates/setObjects.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const updates_1 = require("./updates");
+class SetObject extends updates_1.UpdateExpr {
+    constructor(column, value) {
+        super();
+        this.toQuery = (position) => {
+            const nextPosition = position || 1;
+            const valueToInsert = this._value === null || this._value === undefined
+                ? this._value
+                : this._column.getColumnType().insertStrategy(this._value);
+            const query = `"${this._column.getColumnName()}"=$${nextPosition}`;
+            return { query, values: [valueToInsert] };
+        };
+        this._column = column;
+        this._value = value;
+    }
+}
+exports.default = SetObject;

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

@@ -0,0 +1,7 @@
+import { AbstractColumn } from '../../../columns/column';
+import ColumnType from '../../../columns/types/columnType';
+import { ExtractCodeType } from '../../../tables/inferTypes';
+import { UpdateCustomExpr, UpdateExpr } from './updates';
+export declare const set: <T extends AbstractColumn<ColumnType<any>, boolean, boolean, any>>(column: T, value: ExtractCodeType<T>) => UpdateExpr;
+export declare const incrementBy: <T extends AbstractColumn<ColumnType<any>, boolean, boolean, any>>(value: number) => UpdateCustomExpr<T>;
+export declare const combine: (updates: Array<UpdateExpr>) => UpdateExpr;

package/dist/src/builders/requestBuilders/updates/static.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 });
+exports.combine = exports.incrementBy = exports.set = void 0;
+const combine_1 = __importDefault(require("./combine"));
+const increment_1 = __importDefault(require("./increment"));
+const setObjects_1 = __importDefault(require("./setObjects"));
+const set = (column, value) => new setObjects_1.default(column, value);
+exports.set = set;
+const incrementBy = (value) => new increment_1.default(value);
+exports.incrementBy = incrementBy;
+const combine = (updates) => new combine_1.default(updates);
+exports.combine = combine;

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

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

package/dist/src/builders/requestBuilders/updates/updates.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateCustomExpr = exports.UpdateExpr = void 0;
+/* eslint-disable max-classes-per-file */
+class UpdateExpr {
+}
+exports.UpdateExpr = UpdateExpr;
+class UpdateCustomExpr extends UpdateExpr {
+}
+exports.UpdateCustomExpr = UpdateCustomExpr;

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

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

package/dist/src/builders/requestBuilders/where/and.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable max-len */
+const where_1 = __importDefault(require("./where"));
+class And extends where_1.default {
+    constructor(expressions) {
+        super();
+        this.toQuery = (position, tableCache) => {
+            let nextPosition = position || 1;
+            const result = ['('];
+            const valuesResult = [];
+            for (let i = 0; i < this.expressions.length; i += 1) {
+                const expression = this.expressions[i];
+                const expressionResult = expression.toQuery(nextPosition, tableCache);
+                valuesResult.push(...expressionResult.values);
+                result.push(expressionResult.query);
+                nextPosition += expressionResult.values.length;
+                if (i < this.expressions.length - 1) {
+                    result.push(' and ');
+                }
+            }
+            result.push(')');
+            return { query: result.join(''), values: valuesResult };
+        };
+        this.expressions = expressions;
+    }
+}
+exports.default = And;

package/dist/src/builders/requestBuilders/where/const.d.ts

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

package/dist/src/builders/requestBuilders/where/const.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-return-assign */
+const ecranate_1 = require("../../../utils/ecranate");
+const where_1 = __importDefault(require("./where"));
+class Const extends where_1.default {
+    constructor(value) {
+        super();
+        this.toQuery = (position) => {
+            const nextPosition = position || 1;
+            if (this.value instanceof Date) {
+                return { query: `$${nextPosition}`, values: [`${this.value.toISOString()}`] };
+            }
+            if (ecranate_1.shouldEcranate(this.value)) {
+                return { query: `$${nextPosition}`, values: [`${this.value.toString()}`] };
+            }
+            return { query: `$${nextPosition}`, values: [this.value] };
+        };
+        this.value = value;
+    }
+}
+exports.default = Const;

package/dist/src/builders/requestBuilders/where/constArray.d.ts

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

package/dist/src/builders/requestBuilders/where/constArray.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ecranate_1 = require("../../../utils/ecranate");
+const where_1 = __importDefault(require("./where"));
+class ConstArray extends where_1.default {
+    constructor(values) {
+        super();
+        this.toQuery = (position) => {
+            let nextPosition = position || 1;
+            const finalArray = [];
+            const finalValues = [];
+            for (let i = 0; i < this.values.length; i += 1) {
+                const value = this.values[i];
+                if (value instanceof Date) {
+                    finalArray.push(`$${nextPosition}`);
+                    finalValues.push(`${value.toISOString()}`);
+                }
+                else if (ecranate_1.shouldEcranate(value)) {
+                    finalArray.push(`$${nextPosition}`);
+                    finalValues.push(`${value.toString()}`);
+                }
+                else {
+                    finalArray.push(`$${nextPosition}`);
+                    finalValues.push(value);
+                }
+                if (i < this.values.length - 1) {
+                    finalArray.push(',');
+                }
+                nextPosition += 1;
+            }
+            return { query: finalArray.join(''), values: finalValues };
+        };
+        this.values = values;
+    }
+}
+exports.default = ConstArray;

package/dist/src/builders/requestBuilders/where/eqWhere.d.ts

@@ -0,0 +1,12 @@
+import Expr from './where';
+export default class EqWhere extends Expr {
+    private left;
+    private right;
+    constructor(left: Expr, right: Expr);
+    toQuery: (position?: number | undefined, tableCache?: {
+        [tableName: string]: string;
+    } | undefined) => {
+        query: string;
+        values: Array<any>;
+    };
+}

package/dist/src/builders/requestBuilders/where/eqWhere.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable max-len */
+const where_1 = __importDefault(require("./where"));
+class EqWhere extends where_1.default {
+    constructor(left, right) {
+        super();
+        this.toQuery = (position, tableCache) => {
+            const rightPreparedValues = this.right.toQuery(position, tableCache);
+            const leftPreparedValues = this.left.toQuery(position, tableCache);
+            return { query: `${leftPreparedValues.query}=${rightPreparedValues.query}`, values: [...leftPreparedValues.values, ...rightPreparedValues.values] };
+        };
+        this.left = left;
+        this.right = right;
+    }
+}
+exports.default = EqWhere;

package/dist/src/builders/requestBuilders/where/greater.d.ts

@@ -0,0 +1,15 @@
+import Expr from './where';
+export default class Greater extends Expr {
+    private left;
+    private right;
+    constructor({ left, right }: {
+        left: Expr;
+        right: Expr;
+    });
+    toQuery: (position: number, tableCache?: {
+        [tableName: string]: string;
+    } | undefined) => {
+        query: string;
+        values: Array<any>;
+    };
+}

package/dist/src/builders/requestBuilders/where/greater.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable max-len */
+const where_1 = __importDefault(require("./where"));
+class Greater extends where_1.default {
+    constructor({ left, right }) {
+        super();
+        this.toQuery = (position, tableCache) => {
+            const rightPreparedValues = this.right.toQuery(position, tableCache);
+            const leftPreparedValues = this.left.toQuery(position, tableCache);
+            return { query: `${leftPreparedValues.query} > ${rightPreparedValues.query}`, values: [...leftPreparedValues.values, ...rightPreparedValues.values] };
+        };
+        this.left = left;
+        this.right = right;
+    }
+}
+exports.default = Greater;

package/dist/src/builders/requestBuilders/where/greaterEq.d.ts

@@ -0,0 +1,15 @@
+import Expr from './where';
+export default class GreaterEq extends Expr {
+    private left;
+    private right;
+    constructor({ left, right }: {
+        left: Expr;
+        right: Expr;
+    });
+    toQuery: (position: number, tableCache?: {
+        [tableName: string]: string;
+    } | undefined) => {
+        query: string;
+        values: Array<any>;
+    };
+}

package/dist/src/builders/requestBuilders/where/greaterEq.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable max-len */
+const where_1 = __importDefault(require("./where"));
+class GreaterEq extends where_1.default {
+    constructor({ left, right }) {
+        super();
+        this.toQuery = (position, tableCache) => {
+            const rightPreparedValues = this.right.toQuery(position, tableCache);
+            const leftPreparedValues = this.left.toQuery(position, tableCache);
+            return { query: `${leftPreparedValues.query} >= ${rightPreparedValues.query}`, values: [...leftPreparedValues.values, ...rightPreparedValues.values] };
+        };
+        this.left = left;
+        this.right = right;
+    }
+}
+exports.default = GreaterEq;

package/dist/src/builders/requestBuilders/where/in.d.ts

@@ -0,0 +1,12 @@
+import Expr from './where';
+export default class In extends Expr {
+    private left;
+    private right;
+    constructor(left: Expr, right: Expr);
+    toQuery: (position?: number | undefined, tableCache?: {
+        [tableName: string]: string;
+    } | undefined) => {
+        query: string;
+        values: Array<any>;
+    };
+}

package/dist/src/builders/requestBuilders/where/in.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable max-len */
+const where_1 = __importDefault(require("./where"));
+class In extends where_1.default {
+    constructor(left, right) {
+        super();
+        this.toQuery = (position, tableCache) => {
+            const rightPreparedValues = this.right.toQuery(position, tableCache);
+            const leftPreparedValues = this.left.toQuery(position, tableCache);
+            return { query: `${leftPreparedValues.query} in (${rightPreparedValues.query})`, values: [...leftPreparedValues.values, ...rightPreparedValues.values] };
+        };
+        this.left = left;
+        this.right = right;
+    }
+}
+exports.default = In;

package/dist/src/builders/requestBuilders/where/isNotNull.d.ts

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

package/dist/src/builders/requestBuilders/where/isNotNull.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 });
+/* eslint-disable max-len */
+const where_1 = __importDefault(require("./where"));
+class IsNotNull extends where_1.default {
+    constructor(left) {
+        super();
+        this.toQuery = (position, tableCache) => {
+            const leftPreparedValues = this.left.toQuery(position, tableCache);
+            return { query: `${leftPreparedValues.query} is not null`, values: leftPreparedValues.values };
+        };
+        this.left = left;
+    }
+}
+exports.default = IsNotNull;

package/dist/src/builders/requestBuilders/where/isNull.d.ts

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

package/dist/src/builders/requestBuilders/where/isNull.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 });
+/* eslint-disable max-len */
+const where_1 = __importDefault(require("./where"));
+class IsNull extends where_1.default {
+    constructor(left) {
+        super();
+        this.toQuery = (position, tableCache) => {
+            const leftPreparedValues = this.left.toQuery(position, tableCache);
+            return { query: `${leftPreparedValues.query} is null`, values: leftPreparedValues.values };
+        };
+        this.left = left;
+    }
+}
+exports.default = IsNull;

package/dist/src/builders/requestBuilders/where/less.d.ts

@@ -0,0 +1,15 @@
+import Expr from './where';
+export default class Less extends Expr {
+    private left;
+    private right;
+    constructor({ left, right }: {
+        left: Expr;
+        right: Expr;
+    });
+    toQuery: (position?: number | undefined, tableCache?: {
+        [tableName: string]: string;
+    } | undefined) => {
+        query: string;
+        values: Array<any>;
+    };
+}

package/dist/src/builders/requestBuilders/where/less.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable max-len */
+const where_1 = __importDefault(require("./where"));
+class Less extends where_1.default {
+    constructor({ left, right }) {
+        super();
+        this.toQuery = (position, tableCache) => {
+            const rightPreparedValues = this.right.toQuery(position, tableCache);
+            const leftPreparedValues = this.left.toQuery(position, tableCache);
+            return { query: `${leftPreparedValues.query} < ${rightPreparedValues.query}`, values: [...leftPreparedValues.values, ...rightPreparedValues.values] };
+        };
+        this.left = left;
+        this.right = right;
+    }
+}
+exports.default = Less;

package/dist/src/builders/requestBuilders/where/lessEq.d.ts

@@ -0,0 +1,15 @@
+import Expr from './where';
+export default class LessEq extends Expr {
+    private left;
+    private right;
+    constructor({ left, right }: {
+        left: Expr;
+        right: Expr;
+    });
+    toQuery: (position?: number | undefined, tableCache?: {
+        [tableName: string]: string;
+    } | undefined) => {
+        query: string;
+        values: Array<any>;
+    };
+}

package/dist/src/builders/requestBuilders/where/lessEq.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable max-len */
+const where_1 = __importDefault(require("./where"));
+class LessEq extends where_1.default {
+    constructor({ left, right }) {
+        super();
+        this.toQuery = (position, tableCache) => {
+            const rightPreparedValues = this.right.toQuery(position, tableCache);
+            const leftPreparedValues = this.left.toQuery(position, tableCache);
+            return { query: `${leftPreparedValues.query} <= ${rightPreparedValues.query}`, values: [...leftPreparedValues.values, ...rightPreparedValues.values] };
+        };
+        this.left = left;
+        this.right = right;
+    }
+}
+exports.default = LessEq;

package/dist/src/builders/requestBuilders/where/like.d.ts

@@ -0,0 +1,12 @@
+import Expr from './where';
+export default class Like extends Expr {
+    private left;
+    private right;
+    constructor(left: Expr, right: Expr);
+    toQuery: (position?: number | undefined, tableCache?: {
+        [tableName: string]: string;
+    } | undefined) => {
+        query: string;
+        values: Array<any>;
+    };
+}

package/dist/src/builders/requestBuilders/where/like.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable max-len */
+const where_1 = __importDefault(require("./where"));
+class Like extends where_1.default {
+    constructor(left, right) {
+        super();
+        this.toQuery = (position, tableCache) => {
+            const rightPreparedValues = this.right.toQuery(position, tableCache);
+            const leftPreparedValues = this.left.toQuery(position, tableCache);
+            return { query: `${leftPreparedValues.query} like ${rightPreparedValues.query}`, values: [...leftPreparedValues.values, ...rightPreparedValues.values] };
+        };
+        this.left = left;
+        this.right = right;
+    }
+}
+exports.default = Like;

package/dist/src/builders/requestBuilders/where/notEqWhere.d.ts

@@ -0,0 +1,12 @@
+import Expr from './where';
+export default class NotEqWhere extends Expr {
+    private left;
+    private right;
+    constructor(left: Expr, right: Expr);
+    toQuery: (position?: number | undefined, tableCache?: {
+        [tableName: string]: string;
+    } | undefined) => {
+        query: string;
+        values: Array<any>;
+    };
+}

package/dist/src/builders/requestBuilders/where/notEqWhere.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable max-len */
+const where_1 = __importDefault(require("./where"));
+class NotEqWhere extends where_1.default {
+    constructor(left, right) {
+        super();
+        this.toQuery = (position, tableCache) => {
+            const rightPreparedValues = this.right.toQuery(position, tableCache);
+            const leftPreparedValues = this.left.toQuery(position, tableCache);
+            return { query: `${leftPreparedValues.query}!=${rightPreparedValues.query}`, values: [...leftPreparedValues.values, ...rightPreparedValues.values] };
+        };
+        this.left = left;
+        this.right = right;
+    }
+}
+exports.default = NotEqWhere;

package/dist/src/builders/requestBuilders/where/or.d.ts

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