drizzle-orm 0.9.0 → 0.9.4

package/builders/requestBuilders/where/greater.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const where_1 = require("./where");
+class Greater extends where_1.default {
+    constructor({ left, right }) {
+        super();
+        this.toQuery = () => `${this.left.toQuery()} > ${this.right.toQuery()}`;
+        this.left = left;
+        this.right = right;
+    }
+}
+exports.default = Greater;

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

@@ -0,0 +1,10 @@
+import Expr from './where';
+export default class GreaterEq extends Expr {
+    private left;
+    private right;
+    constructor({ left, right }: {
+        left: Expr;
+        right: Expr;
+    });
+    toQuery: () => string;
+}

package/builders/requestBuilders/where/greaterEq.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const where_1 = require("./where");
+class GreaterEq extends where_1.default {
+    constructor({ left, right }) {
+        super();
+        this.toQuery = () => `${this.left.toQuery()} >= ${this.right.toQuery()}`;
+        this.left = left;
+        this.right = right;
+    }
+}
+exports.default = GreaterEq;

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

@@ -0,0 +1,7 @@
+import Expr from './where';
+export default class In extends Expr {
+    private left;
+    private right;
+    constructor(left: Expr, right: Expr);
+    toQuery: () => string;
+}

package/builders/requestBuilders/where/in.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const where_1 = require("./where");
+class In extends where_1.default {
+    constructor(left, right) {
+        super();
+        this.toQuery = () => `${this.left.toQuery()} in (${this.right.toQuery()})`;
+        this.left = left;
+        this.right = right;
+    }
+}
+exports.default = In;

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

@@ -0,0 +1,6 @@
+import Expr from './where';
+export default class IsNull extends Expr {
+    private left;
+    constructor(left: Expr);
+    toQuery: () => string;
+}

package/builders/requestBuilders/where/isNull.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const where_1 = require("./where");
+class IsNull extends where_1.default {
+    constructor(left) {
+        super();
+        this.toQuery = () => `${this.left.toQuery()} is null`;
+        this.left = left;
+    }
+}
+exports.default = IsNull;

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

@@ -0,0 +1,10 @@
+import Expr from './where';
+export default class Less extends Expr {
+    private left;
+    private right;
+    constructor({ left, right }: {
+        left: Expr;
+        right: Expr;
+    });
+    toQuery: () => string;
+}

package/builders/requestBuilders/where/less.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const where_1 = require("./where");
+class Less extends where_1.default {
+    constructor({ left, right }) {
+        super();
+        this.toQuery = () => `${this.left.toQuery()} < ${this.right.toQuery()}`;
+        this.left = left;
+        this.right = right;
+    }
+}
+exports.default = Less;

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

@@ -0,0 +1,10 @@
+import Expr from './where';
+export default class LessEq extends Expr {
+    private left;
+    private right;
+    constructor({ left, right }: {
+        left: Expr;
+        right: Expr;
+    });
+    toQuery: () => string;
+}

package/builders/requestBuilders/where/lessEq.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const where_1 = require("./where");
+class LessEq extends where_1.default {
+    constructor({ left, right }) {
+        super();
+        this.toQuery = () => `${this.left.toQuery()} <= ${this.right.toQuery()}`;
+        this.left = left;
+        this.right = right;
+    }
+}
+exports.default = LessEq;

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

@@ -0,0 +1,7 @@
+import Expr from './where';
+export default class Like extends Expr {
+    private left;
+    private right;
+    constructor(left: Expr, right: Expr);
+    toQuery: () => string;
+}

package/builders/requestBuilders/where/like.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const where_1 = require("./where");
+class Like extends where_1.default {
+    constructor(left, right) {
+        super();
+        this.toQuery = () => `${this.left.toQuery()} like ${this.right.toQuery()}`;
+        this.left = left;
+        this.right = right;
+    }
+}
+exports.default = Like;

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

@@ -0,0 +1,7 @@
+import Expr from './where';
+export default class NotEqWhere extends Expr {
+    private left;
+    private right;
+    constructor(left: Expr, right: Expr);
+    toQuery: () => string;
+}

package/builders/requestBuilders/where/notEqWhere.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const where_1 = require("./where");
+class NotEqWhere extends where_1.default {
+    constructor(left, right) {
+        super();
+        this.toQuery = () => `${this.left.toQuery()}!=${this.right.toQuery()}`;
+        this.left = left;
+        this.right = right;
+    }
+}
+exports.default = NotEqWhere;

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

@@ -0,0 +1,6 @@
+import Expr from './where';
+export default class Or extends Expr {
+    private expressions;
+    constructor(expressions: Expr[]);
+    toQuery: () => string;
+}

package/builders/requestBuilders/where/or.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const where_1 = require("./where");
+class Or extends where_1.default {
+    constructor(expressions) {
+        super();
+        this.toQuery = () => {
+            const result = ['('];
+            for (let i = 0; i < this.expressions.length; i += 1) {
+                const expression = this.expressions[i];
+                result.push(expression.toQuery());
+                if (i < this.expressions.length - 1) {
+                    result.push(' or ');
+                }
+            }
+            result.push(')');
+            return result.join('');
+        };
+        this.expressions = expressions;
+    }
+}
+exports.default = Or;

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

@@ -0,0 +1,6 @@
+import Expr from './where';
+export default class RawWhere extends Expr {
+    private custom;
+    constructor(custom: string);
+    toQuery: () => string;
+}

package/builders/requestBuilders/where/rawWhere.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const where_1 = require("./where");
+class RawWhere extends where_1.default {
+    constructor(custom) {
+        super();
+        this.custom = custom;
+        this.toQuery = () => this.custom;
+    }
+}
+exports.default = RawWhere;

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

@@ -0,0 +1,16 @@
+import { AbstractColumn } from '../../../columns/column';
+import ColumnType from '../../../columns/types/columnType';
+import { ExtractCodeType } from '../../../tables/inferTypes';
+import Expr from './where';
+export declare const eq: <T extends AbstractColumn<ColumnType<any>, boolean, boolean>>(left: T, value: ExtractCodeType<T>) => Expr;
+export declare const raw: (customQuery: string) => Expr;
+export declare const and: (expressions: Expr[]) => Expr;
+export declare const or: (expressions: Expr[]) => Expr;
+export declare const like: <T extends AbstractColumn<ColumnType<any>, boolean, boolean>>(left: T, value: ExtractCodeType<T>) => Expr;
+export declare const inArray: <T extends AbstractColumn<ColumnType<any>, boolean, boolean>>(left: T, value: ExtractCodeType<T>[]) => Expr;
+export declare const greater: <T extends AbstractColumn<ColumnType<any>, boolean, boolean>>(left: T, value: ExtractCodeType<T>) => Expr;
+export declare const less: <T extends AbstractColumn<ColumnType<any>, boolean, boolean>>(left: T, value: ExtractCodeType<T>) => Expr;
+export declare const greaterEq: <T extends AbstractColumn<ColumnType<any>, boolean, boolean>>(left: T, value: ExtractCodeType<T>) => Expr;
+export declare const lessEq: <T extends AbstractColumn<ColumnType<any>, boolean, boolean>>(left: T, value: ExtractCodeType<T>) => Expr;
+export declare const isNull: <T extends AbstractColumn<ColumnType<any>, boolean, boolean>>(left: T) => Expr;
+export declare const notEq: <T extends AbstractColumn<ColumnType<any>, boolean, boolean>>(left: T, value: ExtractCodeType<T>) => Expr;

package/builders/requestBuilders/where/static.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notEq = exports.isNull = exports.lessEq = exports.greaterEq = exports.less = exports.greater = exports.inArray = exports.like = exports.or = exports.and = exports.raw = exports.eq = void 0;
+const and_1 = require("./and");
+const const_1 = require("./const");
+const constArray_1 = require("./constArray");
+const eqWhere_1 = require("./eqWhere");
+const greater_1 = require("./greater");
+const greaterEq_1 = require("./greaterEq");
+const in_1 = require("./in");
+const isNull_1 = require("./isNull");
+const less_1 = require("./less");
+const lessEq_1 = require("./lessEq");
+const like_1 = require("./like");
+const notEqWhere_1 = require("./notEqWhere");
+const or_1 = require("./or");
+const rawWhere_1 = require("./rawWhere");
+const var_1 = require("./var");
+// eslint-disable-next-line max-len
+const eq = (left, value) => new eqWhere_1.default(new var_1.default(left), new const_1.default(value));
+exports.eq = eq;
+const raw = (customQuery) => new rawWhere_1.default(customQuery);
+exports.raw = raw;
+const and = (expressions) => new and_1.default(expressions);
+exports.and = and;
+const or = (expressions) => new or_1.default(expressions);
+exports.or = or;
+const like = (left, value) => new like_1.default(new var_1.default(left), new const_1.default(value));
+exports.like = like;
+const inArray = (left, value) => new in_1.default(new var_1.default(left), new constArray_1.default(value));
+exports.inArray = inArray;
+const greater = (left, value) => new greater_1.default({ left: new var_1.default(left), right: new const_1.default(value) });
+exports.greater = greater;
+const less = (left, value) => new less_1.default({ left: new var_1.default(left), right: new const_1.default(value) });
+exports.less = less;
+const greaterEq = (left, value) => new greaterEq_1.default({ left: new var_1.default(left), right: new const_1.default(value) });
+exports.greaterEq = greaterEq;
+const lessEq = (left, value) => new lessEq_1.default({ left: new var_1.default(left), right: new const_1.default(value) });
+exports.lessEq = lessEq;
+const isNull = (left) => new isNull_1.default(new var_1.default(left));
+exports.isNull = isNull;
+const notEq = (left, value) => new notEqWhere_1.default(new var_1.default(left), new const_1.default(value));
+exports.notEq = notEq;

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

@@ -0,0 +1,8 @@
+import { AbstractColumn } from '../../../columns/column';
+import ColumnType from '../../../columns/types/columnType';
+import Expr from './where';
+export default class Var<T extends AbstractColumn<ColumnType<any>, boolean, boolean>> extends Expr {
+    private column;
+    constructor(column: T);
+    toQuery: () => string;
+}

package/builders/requestBuilders/where/var.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ecranate_1 = require("../../../utils/ecranate");
+const where_1 = require("./where");
+class Var extends where_1.default {
+    constructor(column) {
+        super();
+        this.toQuery = () => `${this.column.getParentName()}.${ecranate_1.ecranate(this.column.getColumnName())}`;
+        this.column = column;
+    }
+}
+exports.default = Var;

package/{src/builders/requestBuilders/where/where.ts → builders/requestBuilders/where/where.d.ts}

@@ -1,3 +1,3 @@
 export default abstract class Expr {
-  abstract toQuery(): string;
+    abstract toQuery(): string;
 }

package/builders/requestBuilders/where/where.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Expr {
+}
+exports.default = Expr;

package/builders/transaction/transaction.d.ts

@@ -0,0 +1,8 @@
+import Session from '../../db/session';
+export default class Transaction {
+    private session;
+    constructor(session: Session);
+    begin: () => Promise<Transaction>;
+    commit: () => Promise<Transaction>;
+    rollback: () => Promise<Transaction>;
+}

package/builders/transaction/transaction.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Transaction {
+    constructor(session) {
+        this.session = session;
+        this.begin = async () => {
+            await this.session.execute('BEGIN;');
+            return this;
+        };
+        this.commit = async () => {
+            await this.session.execute('COMMIT;');
+            return this;
+        };
+        this.rollback = async () => {
+            await this.session.execute('ROLLBACK;');
+            return this;
+        };
+    }
+}
+exports.default = Transaction;

package/columns/column.d.ts

@@ -0,0 +1,61 @@
+import DB from '../db/db';
+import { AbstractTable } from '../tables';
+import ColumnType from './types/columnType';
+declare type ExtractColumnType<T extends ColumnType> = T extends ColumnType<infer TCodeType> ? TCodeType : never;
+export declare enum OnDelete {
+    RESTRICT = "ON DELETE RESTRICT",
+    CASCADE = "ON DELETE CASCADE"
+}
+export declare enum OnUpdate {
+    RESTRICT = "ON UPDATE RESTRICT",
+    CASCADE = "ON UPDATE RESTRICT"
+}
+export declare abstract class AbstractColumn<T extends ColumnType, TNullable extends boolean = true, TAutoIncrement extends boolean = false> {
+    isNullableFlag: TNullable;
+    autoIncrementType: TAutoIncrement;
+    primaryKeyName?: string;
+    uniqueKeyName?: string;
+    protected onDelete?: string;
+    protected onUpdate?: string;
+    protected parent: AbstractTable<any>;
+    protected parentTableName: string;
+    protected columnType: T;
+    protected columnName: string;
+    protected autoIncrementFlag: boolean;
+    protected defaultParam: any;
+    protected referenced: AbstractColumn<T, boolean, boolean>;
+    constructor(parent: AbstractTable<any>, columnName: string, columnType: T, nullable: TNullable);
+    getOnDelete: () => string | undefined;
+    getOnUpdate: () => string | undefined;
+    getAlias: () => string;
+    getParent: () => AbstractTable<any>;
+    getParentName: () => string;
+    abstract foreignKey<ITable extends AbstractTable<ITable>>(table: {
+        new (db: DB): ITable;
+    }, callback: (table: ITable) => AbstractColumn<T, boolean, boolean>, onDelete?: OnDelete, onUpdate?: OnUpdate): AbstractColumn<T, TNullable, TAutoIncrement>;
+    defaultValue: (value: ExtractColumnType<T>) => this;
+    abstract autoIncrement(): AbstractColumn<T, boolean, boolean>;
+    abstract primaryKey(): AbstractColumn<T, boolean, boolean>;
+    abstract serial(): AbstractColumn<T, boolean, boolean>;
+    unique: () => this;
+    isAutoIncrement: () => boolean;
+    getColumnName: () => string;
+    getReferenced: () => AbstractColumn<T, boolean, boolean>;
+    getColumnType: () => T;
+    getDefaultValue: () => any;
+}
+export declare class Column<T extends ColumnType, TNullable extends boolean = true, TAutoIncrement extends boolean = false> extends AbstractColumn<T, TNullable, TAutoIncrement> {
+    constructor(parent: AbstractTable<any>, columnName: string, columnType: T, nullable: TNullable);
+    serial(): Column<T, false, true>;
+    primaryKey(): Column<T, TAutoIncrement extends true ? true : false, TAutoIncrement>;
+    foreignKey<ITable extends AbstractTable<ITable>>(table: new (db: DB) => ITable, callback: (table: ITable) => Column<T, boolean, boolean>, onDelete?: OnDelete, onUpdate?: OnUpdate): Column<T, TNullable, TAutoIncrement>;
+    autoIncrement(): IndexedColumn<T, true, true>;
+}
+export declare class IndexedColumn<T extends ColumnType, TNullable extends boolean = true, TAutoIncrement extends boolean = false> extends AbstractColumn<T, TNullable, TAutoIncrement> {
+    constructor(parent: AbstractTable<any>, columnName: string, columnType: T, nullable: TNullable);
+    serial(): IndexedColumn<T, false, true>;
+    primaryKey(): IndexedColumn<T, TAutoIncrement extends true ? true : false, TAutoIncrement>;
+    foreignKey<ITable extends AbstractTable<ITable>>(table: new (db: DB) => ITable, callback: (table: ITable) => IndexedColumn<T, boolean, boolean>, onDelete?: OnDelete, onUpdate?: OnUpdate): IndexedColumn<T, TNullable, TAutoIncrement>;
+    autoIncrement(): IndexedColumn<T, true, true>;
+}
+export {};

package/columns/column.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexedColumn = exports.Column = exports.AbstractColumn = exports.OnUpdate = exports.OnDelete = void 0;
+var OnDelete;
+(function (OnDelete) {
+    OnDelete["RESTRICT"] = "ON DELETE RESTRICT";
+    OnDelete["CASCADE"] = "ON DELETE CASCADE";
+})(OnDelete = exports.OnDelete || (exports.OnDelete = {}));
+var OnUpdate;
+(function (OnUpdate) {
+    OnUpdate["RESTRICT"] = "ON UPDATE RESTRICT";
+    OnUpdate["CASCADE"] = "ON UPDATE RESTRICT";
+})(OnUpdate = exports.OnUpdate || (exports.OnUpdate = {}));
+// eslint-disable-next-line max-len
+class AbstractColumn {
+    constructor(parent, columnName, columnType, nullable) {
+        this.autoIncrementFlag = false;
+        this.defaultParam = null;
+        this.getOnDelete = () => this.onDelete;
+        this.getOnUpdate = () => this.onUpdate;
+        this.getAlias = () => `${this.parentTableName.replace('.', '_')}_${this.columnName}`;
+        this.getParent = () => this.parent;
+        this.getParentName = () => this.parentTableName;
+        this.defaultValue = (value) => {
+            this.defaultParam = value;
+            return this;
+        };
+        this.unique = () => {
+            this.uniqueKeyName = this.columnName;
+            return this;
+        };
+        this.isAutoIncrement = () => this.autoIncrementFlag;
+        this.getColumnName = () => this.columnName;
+        this.getReferenced = () => this.referenced;
+        this.getColumnType = () => this.columnType;
+        this.getDefaultValue = () => this.defaultParam;
+        this.columnType = columnType;
+        this.columnName = columnName;
+        this.parentTableName = parent.tableName();
+        this.parent = parent;
+        this.isNullableFlag = nullable;
+    }
+}
+exports.AbstractColumn = AbstractColumn;
+// eslint-disable-next-line max-len
+class Column extends AbstractColumn {
+    constructor(parent, columnName, columnType, nullable) {
+        super(parent, columnName, columnType, nullable);
+    }
+    serial() {
+        this.autoIncrementFlag = true;
+        return this;
+    }
+    primaryKey() {
+        this.primaryKeyName = `${this.parentTableName}_${this.columnName}`;
+        // eslint-disable-next-line max-len
+        return this;
+    }
+    foreignKey(table, callback, onDelete, onUpdate) {
+        const tableInstance = this.getParent().db.create(table);
+        this.referenced = callback(tableInstance);
+        this.onDelete = onDelete;
+        this.onUpdate = onUpdate;
+        return this;
+    }
+    autoIncrement() {
+        this.autoIncrementFlag = true;
+        return this;
+    }
+}
+exports.Column = Column;
+// eslint-disable-next-line max-len
+class IndexedColumn extends AbstractColumn {
+    constructor(parent, columnName, columnType, nullable) {
+        super(parent, columnName, columnType, nullable);
+    }
+    serial() {
+        this.autoIncrementFlag = true;
+        return this;
+    }
+    primaryKey() {
+        this.primaryKeyName = `${this.parentTableName}_${this.columnName}`;
+        // eslint-disable-next-line max-len
+        return this;
+    }
+    foreignKey(table, callback, onDelete, onUpdate) {
+        // eslint-disable-next-line new-cap
+        this.referenced = callback(this.getParent().db.create(table));
+        this.onDelete = onDelete;
+        this.onUpdate = onUpdate;
+        return this;
+    }
+    autoIncrement() {
+        this.autoIncrementFlag = true;
+        return this;
+    }
+}
+exports.IndexedColumn = IndexedColumn;

package/columns/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PgVarChar = exports.PgTimestamp = exports.PgTime = exports.PgText = exports.PgJsonb = exports.PgInteger = exports.PgBoolean = exports.PgBigInt = exports.PgBigDecimal = exports.Column = void 0;
+var column_1 = require("./column");
+Object.defineProperty(exports, "Column", { enumerable: true, get: function () { return column_1.Column; } });
+var pgBigDecimal_1 = require("./types/pgBigDecimal");
+Object.defineProperty(exports, "PgBigDecimal", { enumerable: true, get: function () { return pgBigDecimal_1.default; } });
+var pgBigInt_1 = require("./types/pgBigInt");
+Object.defineProperty(exports, "PgBigInt", { enumerable: true, get: function () { return pgBigInt_1.default; } });
+var pgBoolean_1 = require("./types/pgBoolean");
+Object.defineProperty(exports, "PgBoolean", { enumerable: true, get: function () { return pgBoolean_1.default; } });
+var pgInteger_1 = require("./types/pgInteger");
+Object.defineProperty(exports, "PgInteger", { enumerable: true, get: function () { return pgInteger_1.default; } });
+var pgJsonb_1 = require("./types/pgJsonb");
+Object.defineProperty(exports, "PgJsonb", { enumerable: true, get: function () { return pgJsonb_1.default; } });
+var pgText_1 = require("./types/pgText");
+Object.defineProperty(exports, "PgText", { enumerable: true, get: function () { return pgText_1.default; } });
+var pgTime_1 = require("./types/pgTime");
+Object.defineProperty(exports, "PgTime", { enumerable: true, get: function () { return pgTime_1.default; } });
+var pgTimestamp_1 = require("./types/pgTimestamp");
+Object.defineProperty(exports, "PgTimestamp", { enumerable: true, get: function () { return pgTimestamp_1.default; } });
+var pgVarChar_1 = require("./types/pgVarChar");
+Object.defineProperty(exports, "PgVarChar", { enumerable: true, get: function () { return pgVarChar_1.default; } });

package/columns/types/columnType.d.ts

@@ -0,0 +1,7 @@
+export default abstract class ColumnType<TCodeType = {}> {
+    codeType: TCodeType;
+    protected abstract dbName: string;
+    abstract getDbName(): string;
+    abstract insertStrategy(value: TCodeType): string;
+    abstract selectStrategy(value: any): TCodeType;
+}

package/columns/types/columnType.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// eslint-disable-next-line max-classes-per-file
+class ColumnType {
+}
+exports.default = ColumnType;

package/columns/types/pgBigDecimal.d.ts

@@ -0,0 +1,10 @@
+import ColumnType from './columnType';
+export default class PgBigDecimal extends ColumnType<number> {
+    precision?: number;
+    scale?: number;
+    dbName: string;
+    constructor(precision?: number, scale?: number);
+    getDbName: () => string;
+    insertStrategy: (value: number) => string;
+    selectStrategy(value: string): number;
+}

package/columns/types/pgBigDecimal.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const columnType_1 = require("./columnType");
+class PgBigDecimal extends columnType_1.default {
+    constructor(precision, scale) {
+        super();
+        this.getDbName = () => this.dbName;
+        this.insertStrategy = (value) => `${value}`;
+        this.precision = precision;
+        this.scale = scale;
+        if (this.scale && !this.precision) {
+            throw new Error('In numeric scale should be set up together with precision');
+        }
+        if (this.precision && !this.scale) {
+            this.dbName = `numeric(${this.precision})`;
+        }
+        else if (this.precision && this.scale) {
+            this.dbName = `numeric(${this.precision},${this.scale})`;
+        }
+        else {
+            this.dbName = 'numeric';
+        }
+    }
+    selectStrategy(value) {
+        return parseFloat(value);
+    }
+}
+exports.default = PgBigDecimal;

package/columns/types/pgBigInt.d.ts

@@ -0,0 +1,8 @@
+import ColumnType from './columnType';
+export default class PgBigInt extends ColumnType<number> {
+    dbName: string;
+    constructor();
+    getDbName(): string;
+    insertStrategy: (value: number) => string;
+    selectStrategy(value: string): number;
+}

package/columns/types/pgBigInt.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const columnType_1 = require("./columnType");
+class PgBigInt extends columnType_1.default {
+    constructor() {
+        super();
+        this.insertStrategy = (value) => `${value}`;
+        this.dbName = 'BIGINT';
+    }
+    getDbName() {
+        return this.dbName;
+    }
+    selectStrategy(value) {
+        return parseInt(value, 10);
+    }
+}
+exports.default = PgBigInt;

package/columns/types/pgBoolean.d.ts

@@ -0,0 +1,8 @@
+import ColumnType from './columnType';
+export default class PgBoolean extends ColumnType<boolean> {
+    dbName: string;
+    constructor();
+    getDbName: () => string;
+    insertStrategy: (value: boolean) => string;
+    selectStrategy(value: boolean): boolean;
+}