drizzle-orm 0.10.21 → 0.10.24

package/dist/src/builders/requestBuilders/where/or.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 Or 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(' or ');
+                }
+            }
+            result.push(')');
+            return { query: result.join(''), values: valuesResult };
+        };
+        this.expressions = expressions;
+    }
+}
+exports.default = Or;

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

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

package/dist/src/builders/requestBuilders/where/rawWhere.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 });
+/* eslint-disable max-len */
+const where_1 = __importDefault(require("./where"));
+class RawWhere extends where_1.default {
+    constructor(custom) {
+        super();
+        this.custom = custom;
+        this.toQuery = () => ({ query: this.custom, values: [] });
+    }
+}
+exports.default = RawWhere;

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

@@ -0,0 +1,17 @@
+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, any>>(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, any>>(left: T, value: ExtractCodeType<T>) => Expr;
+export declare const inArray: <T extends AbstractColumn<ColumnType<any>, boolean, boolean, any>>(left: T, value: ExtractCodeType<T>[]) => Expr;
+export declare const greater: <T extends AbstractColumn<ColumnType<any>, boolean, boolean, any>>(left: T, value: ExtractCodeType<T>) => Expr;
+export declare const less: <T extends AbstractColumn<ColumnType<any>, boolean, boolean, any>>(left: T, value: ExtractCodeType<T>) => Expr;
+export declare const greaterEq: <T extends AbstractColumn<ColumnType<any>, boolean, boolean, any>>(left: T, value: ExtractCodeType<T>) => Expr;
+export declare const lessEq: <T extends AbstractColumn<ColumnType<any>, boolean, boolean, any>>(left: T, value: ExtractCodeType<T>) => Expr;
+export declare const isNull: <T extends AbstractColumn<ColumnType<any>, boolean, boolean, any>>(left: T) => Expr;
+export declare const isNotNull: <T extends AbstractColumn<ColumnType<any>, boolean, boolean, any>>(left: T) => Expr;
+export declare const notEq: <T extends AbstractColumn<ColumnType<any>, boolean, boolean, any>>(left: T, value: ExtractCodeType<T>) => Expr;

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

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notEq = exports.isNotNull = 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 = __importDefault(require("./and"));
+const const_1 = __importDefault(require("./const"));
+const constArray_1 = __importDefault(require("./constArray"));
+const eqWhere_1 = __importDefault(require("./eqWhere"));
+const greater_1 = __importDefault(require("./greater"));
+const greaterEq_1 = __importDefault(require("./greaterEq"));
+const in_1 = __importDefault(require("./in"));
+const isNotNull_1 = __importDefault(require("./isNotNull"));
+const isNull_1 = __importDefault(require("./isNull"));
+const less_1 = __importDefault(require("./less"));
+const lessEq_1 = __importDefault(require("./lessEq"));
+const like_1 = __importDefault(require("./like"));
+const notEqWhere_1 = __importDefault(require("./notEqWhere"));
+const or_1 = __importDefault(require("./or"));
+const rawWhere_1 = __importDefault(require("./rawWhere"));
+const var_1 = __importDefault(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 isNotNull = (left) => new isNotNull_1.default(new var_1.default(left));
+exports.isNotNull = isNotNull;
+const notEq = (left, value) => new notEqWhere_1.default(new var_1.default(left), new const_1.default(value));
+exports.notEq = notEq;

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

@@ -0,0 +1,13 @@
+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: (postition?: number | undefined, tableCache?: {
+        [tableName: string]: string;
+    } | undefined) => {
+        query: string;
+        values: Array<any>;
+    };
+}

package/dist/src/builders/requestBuilders/where/var.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 ecranate_1 = require("../../../utils/ecranate");
+const where_1 = __importDefault(require("./where"));
+class Var extends where_1.default {
+    constructor(column) {
+        super();
+        this.toQuery = (postition, tableCache) => {
+            const tableName = tableCache && tableCache[this.column.getParentName()] ? tableCache[this.column.getParentName()] : this.column.getParentName();
+            return { query: `${tableName}.${ecranate_1.ecranate(this.column.getColumnName())}`, values: [] };
+        };
+        this.column = column;
+    }
+}
+exports.default = Var;

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

@@ -0,0 +1,8 @@
+export default abstract class Expr {
+    abstract toQuery(position?: number, tableCache?: {
+        [tableName: string]: string;
+    }): {
+        query: string;
+        values: Array<any>;
+    };
+}

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

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

package/dist/src/builders/transaction/transaction.d.ts

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

package/dist/src/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/dist/src/columns/column.d.ts

@@ -0,0 +1,72 @@
+import { PgTime, PgTimestamp } from '.';
+import DB from '../db/db';
+import { AbstractTable } from '../tables';
+import ColumnType from './types/columnType';
+import PgTimestamptz from './types/pgTimestamptz';
+export declare enum Defaults {
+    CURRENT_TIMESTAMP = "CURRENT_TIMESTAMP"
+}
+declare type PgTimes = PgTimestamptz | PgTime | PgTimestamp;
+export declare type ExtractColumnType<T extends ColumnType> = T extends ColumnType<infer TCodeType> ? T extends PgTimes ? TCodeType | Defaults : TCodeType : never;
+export declare abstract class AbstractColumn<T extends ColumnType, TNullable extends boolean = true, TAutoIncrement extends boolean = false, TParent extends AbstractTable<any> = any> {
+    isNullableFlag: boolean;
+    primaryKeyName?: string;
+    uniqueKeyName?: string;
+    protected onDelete?: string;
+    protected onUpdate?: string;
+    protected parent: TParent;
+    protected parentTableName: string;
+    protected columnType: T;
+    protected columnName: string;
+    protected defaultParam: any;
+    protected referenced: AbstractColumn<T, boolean, boolean>;
+    constructor(parent: TParent, columnName: string, columnType: T);
+    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) => Column<any, boolean, boolean, ITable>, onConstraint?: {
+        onDelete?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'SET DEFAULT';
+        onUpdate?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'SET DEFAULT';
+    }): AbstractColumn<T, TNullable, TAutoIncrement, TParent>;
+    abstract selfForeignKey(column: Column<any, boolean, boolean, TParent>, onConstraint?: {
+        onDelete?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'SET DEFAULT';
+        onUpdate?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'SET DEFAULT';
+    }): AbstractColumn<T, TNullable, TAutoIncrement, TParent>;
+    defaultValue: (value: ExtractColumnType<T>) => this;
+    abstract primaryKey(): AbstractColumn<T, boolean, boolean, TParent>;
+    unique: () => this;
+    abstract notNull(): AbstractColumn<T, boolean, boolean, TParent>;
+    getColumnName: () => string;
+    getReferenced: () => AbstractColumn<T, boolean, boolean, TParent>;
+    getColumnType: () => T;
+    getDefaultValue: () => any;
+}
+export declare class Column<T extends ColumnType, TNullable extends boolean = true, TAutoIncrement extends boolean = false, TParent extends AbstractTable<any> = any> extends AbstractColumn<T, TNullable, TAutoIncrement, TParent> {
+    constructor(parent: TParent, columnName: string, columnType: T);
+    notNull(): Column<T, TAutoIncrement extends true ? true : TNullable extends true ? false : true, TAutoIncrement, TParent>;
+    primaryKey(): Column<T, TAutoIncrement extends true ? true : false, TAutoIncrement, TParent>;
+    foreignKey<ITable extends AbstractTable<ITable>>(table: new (db: DB) => ITable, callback: (table: ITable) => Column<any, boolean, boolean, ITable>, onConstraint?: {
+        onDelete?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'SET DEFAULT';
+        onUpdate?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'SET DEFAULT';
+    }): Column<T, TNullable, TAutoIncrement, TParent>;
+    selfForeignKey(column: Column<any, boolean, boolean, TParent>, onConstraint?: {
+        onDelete?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'SET DEFAULT';
+        onUpdate?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'SET DEFAULT';
+    }): Column<T, TNullable, TAutoIncrement, TParent>;
+}
+export declare class IndexedColumn<T extends ColumnType, TNullable extends boolean = true, TAutoIncrement extends boolean = false, TParent extends AbstractTable<any> = any> extends AbstractColumn<T, TNullable, TAutoIncrement, TParent> {
+    constructor(parent: TParent, columnName: string, columnType: T, nullable: TNullable);
+    notNull(): IndexedColumn<T, TAutoIncrement extends true ? true : TNullable extends true ? false : true, TAutoIncrement, TParent>;
+    primaryKey(): IndexedColumn<T, TAutoIncrement extends true ? true : false, TAutoIncrement, TParent>;
+    foreignKey<ITable extends AbstractTable<ITable>>(table: new (db: DB) => ITable, callback: (table: ITable) => Column<any, boolean, boolean, ITable>, onConstraint?: {
+        onDelete?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'SET DEFAULT';
+        onUpdate?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'SET DEFAULT';
+    }): IndexedColumn<T, TNullable, TAutoIncrement, TParent>;
+    selfForeignKey<ITable extends AbstractTable<ITable>>(column: Column<any, boolean, boolean, TParent>, onConstraint?: {
+        onDelete?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'SET DEFAULT';
+        onUpdate?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'SET DEFAULT';
+    }): IndexedColumn<T, TNullable, TAutoIncrement, TParent>;
+}
+export {};

package/dist/src/columns/column.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexedColumn = exports.Column = exports.AbstractColumn = exports.Defaults = void 0;
+var Defaults;
+(function (Defaults) {
+    Defaults["CURRENT_TIMESTAMP"] = "CURRENT_TIMESTAMP";
+})(Defaults = exports.Defaults || (exports.Defaults = {}));
+// eslint-disable-next-line max-len
+class AbstractColumn {
+    constructor(parent, columnName, columnType) {
+        this.isNullableFlag = true;
+        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) => {
+            if (Defaults[value] !== undefined) {
+                this.defaultParam = value;
+            }
+            else if (typeof value === 'boolean' || typeof value === 'number' || typeof value === 'bigint') {
+                this.defaultParam = value;
+            }
+            else {
+                this.defaultParam = `'${value}'`;
+            }
+            return this;
+        };
+        this.unique = () => {
+            this.uniqueKeyName = this.columnName;
+            return this;
+        };
+        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;
+    }
+}
+exports.AbstractColumn = AbstractColumn;
+// eslint-disable-next-line max-len
+class Column extends AbstractColumn {
+    constructor(parent, columnName, columnType) {
+        super(parent, columnName, columnType);
+    }
+    notNull() {
+        this.isNullableFlag = false;
+        return this;
+    }
+    primaryKey() {
+        this.primaryKeyName = `${this.parentTableName}_${this.columnName}`;
+        return this;
+    }
+    foreignKey(table, callback, onConstraint) {
+        const tableInstance = this.getParent().db.create(table);
+        this.referenced = callback(tableInstance);
+        this.onDelete = (onConstraint === null || onConstraint === void 0 ? void 0 : onConstraint.onDelete) ? `ON DELETE ${onConstraint.onDelete}` : undefined;
+        this.onUpdate = (onConstraint === null || onConstraint === void 0 ? void 0 : onConstraint.onUpdate) ? `ON UPDATE ${onConstraint.onUpdate}` : undefined;
+        return this;
+    }
+    selfForeignKey(column, onConstraint) {
+        this.referenced = column;
+        this.onDelete = (onConstraint === null || onConstraint === void 0 ? void 0 : onConstraint.onDelete) ? `ON DELETE ${onConstraint.onDelete}` : undefined;
+        this.onUpdate = (onConstraint === null || onConstraint === void 0 ? void 0 : onConstraint.onUpdate) ? `ON UPDATE ${onConstraint.onUpdate}` : undefined;
+        return this;
+    }
+}
+exports.Column = Column;
+// eslint-disable-next-line max-len
+class IndexedColumn extends AbstractColumn {
+    constructor(parent, columnName, columnType, nullable) {
+        super(parent, columnName, columnType);
+    }
+    notNull() {
+        this.isNullableFlag = false;
+        return this;
+    }
+    primaryKey() {
+        this.primaryKeyName = `${this.parentTableName}_${this.columnName}`;
+        // eslint-disable-next-line max-len
+        return this;
+    }
+    foreignKey(table, callback, onConstraint) {
+        // eslint-disable-next-line new-cap
+        this.referenced = callback(this.getParent().db.create(table));
+        this.onDelete = (onConstraint === null || onConstraint === void 0 ? void 0 : onConstraint.onDelete) ? `ON DELETE ${onConstraint.onDelete}` : undefined;
+        this.onUpdate = (onConstraint === null || onConstraint === void 0 ? void 0 : onConstraint.onUpdate) ? `ON UPDATE ${onConstraint.onUpdate}` : undefined;
+        return this;
+    }
+    selfForeignKey(column, onConstraint) {
+        this.referenced = column;
+        this.onDelete = (onConstraint === null || onConstraint === void 0 ? void 0 : onConstraint.onDelete) ? `ON DELETE ${onConstraint.onDelete}` : undefined;
+        this.onUpdate = (onConstraint === null || onConstraint === void 0 ? void 0 : onConstraint.onUpdate) ? `ON UPDATE ${onConstraint.onUpdate}` : undefined;
+        return this;
+    }
+}
+exports.IndexedColumn = IndexedColumn;

package/dist/src/columns/index.d.ts

@@ -0,0 +1,10 @@
+export { Column, ExtractColumnType, Defaults } from './column';
+export { default as PgBigDecimal } from './types/pgBigDecimal';
+export { default as PgBigInt } from './types/pgBigInt';
+export { default as PgBoolean } from './types/pgBoolean';
+export { default as PgInteger } from './types/pgInteger';
+export { default as PgJsonb } from './types/pgJsonb';
+export { default as PgText } from './types/pgText';
+export { default as PgTime } from './types/pgTime';
+export { default as PgTimestamp } from './types/pgTimestamp';
+export { default as PgVarChar } from './types/pgVarChar';

package/dist/src/columns/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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.Defaults = exports.Column = void 0;
+var column_1 = require("./column");
+Object.defineProperty(exports, "Column", { enumerable: true, get: function () { return column_1.Column; } });
+Object.defineProperty(exports, "Defaults", { enumerable: true, get: function () { return column_1.Defaults; } });
+var pgBigDecimal_1 = require("./types/pgBigDecimal");
+Object.defineProperty(exports, "PgBigDecimal", { enumerable: true, get: function () { return __importDefault(pgBigDecimal_1).default; } });
+var pgBigInt_1 = require("./types/pgBigInt");
+Object.defineProperty(exports, "PgBigInt", { enumerable: true, get: function () { return __importDefault(pgBigInt_1).default; } });
+var pgBoolean_1 = require("./types/pgBoolean");
+Object.defineProperty(exports, "PgBoolean", { enumerable: true, get: function () { return __importDefault(pgBoolean_1).default; } });
+var pgInteger_1 = require("./types/pgInteger");
+Object.defineProperty(exports, "PgInteger", { enumerable: true, get: function () { return __importDefault(pgInteger_1).default; } });
+var pgJsonb_1 = require("./types/pgJsonb");
+Object.defineProperty(exports, "PgJsonb", { enumerable: true, get: function () { return __importDefault(pgJsonb_1).default; } });
+var pgText_1 = require("./types/pgText");
+Object.defineProperty(exports, "PgText", { enumerable: true, get: function () { return __importDefault(pgText_1).default; } });
+var pgTime_1 = require("./types/pgTime");
+Object.defineProperty(exports, "PgTime", { enumerable: true, get: function () { return __importDefault(pgTime_1).default; } });
+var pgTimestamp_1 = require("./types/pgTimestamp");
+Object.defineProperty(exports, "PgTimestamp", { enumerable: true, get: function () { return __importDefault(pgTimestamp_1).default; } });
+var pgVarChar_1 = require("./types/pgVarChar");
+Object.defineProperty(exports, "PgVarChar", { enumerable: true, get: function () { return __importDefault(pgVarChar_1).default; } });

package/dist/src/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 | undefined;
+}

package/dist/src/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/dist/src/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 | undefined;
+}

package/dist/src/columns/types/pgBigDecimal.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 });
+const columnType_1 = __importDefault(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 value ? parseFloat(value) : undefined;
+    }
+}
+exports.default = PgBigDecimal;

package/dist/src/columns/types/pgBigInt.d.ts

@@ -0,0 +1,15 @@
+import ColumnType from './columnType';
+export default class PgBigInt53 extends ColumnType<number> {
+    dbName: string;
+    constructor();
+    getDbName: () => string;
+    insertStrategy: (value: number) => string;
+    selectStrategy(value: string): number | undefined;
+}
+export declare class PgBigInt64 extends ColumnType<bigint> {
+    dbName: string;
+    constructor();
+    getDbName: () => string;
+    insertStrategy: (value: bigint) => string;
+    selectStrategy(value: string): bigint | undefined;
+}

package/dist/src/columns/types/pgBigInt.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PgBigInt64 = void 0;
+// eslint-disable-next-line max-classes-per-file
+const columnType_1 = __importDefault(require("./columnType"));
+class PgBigInt53 extends columnType_1.default {
+    constructor() {
+        super();
+        this.getDbName = () => this.dbName;
+        this.insertStrategy = (value) => `${value}`;
+        this.dbName = 'BIGINT';
+    }
+    selectStrategy(value) {
+        return value ? parseInt(value, 10) : undefined;
+    }
+}
+exports.default = PgBigInt53;
+class PgBigInt64 extends columnType_1.default {
+    constructor() {
+        super();
+        this.getDbName = () => this.dbName;
+        this.insertStrategy = (value) => `${value}`;
+        this.dbName = 'BIGINT';
+    }
+    selectStrategy(value) {
+        return value ? BigInt(value) : undefined;
+    }
+}
+exports.PgBigInt64 = PgBigInt64;

package/dist/src/columns/types/pgBigSerial.d.ts

@@ -0,0 +1,15 @@
+import ColumnType from './columnType';
+export default class PgBigSerial53 extends ColumnType<number> {
+    dbName: string;
+    constructor();
+    getDbName: () => string;
+    insertStrategy: (value: number) => string;
+    selectStrategy(value: string): number | undefined;
+}
+export declare class PgBigSerial64 extends ColumnType<bigint> {
+    dbName: string;
+    constructor();
+    getDbName: () => string;
+    insertStrategy: (value: bigint) => string;
+    selectStrategy(value: string): bigint | undefined;
+}

package/dist/src/columns/types/pgBigSerial.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PgBigSerial64 = void 0;
+/* eslint-disable max-classes-per-file */
+const columnType_1 = __importDefault(require("./columnType"));
+class PgBigSerial53 extends columnType_1.default {
+    constructor() {
+        super();
+        this.getDbName = () => this.dbName;
+        this.insertStrategy = (value) => `${value}`;
+        this.dbName = 'BIGSERIAL';
+    }
+    selectStrategy(value) {
+        return value ? parseInt(value, 10) : undefined;
+    }
+}
+exports.default = PgBigSerial53;
+class PgBigSerial64 extends columnType_1.default {
+    constructor() {
+        super();
+        this.getDbName = () => this.dbName;
+        this.insertStrategy = (value) => `${value}`;
+        this.dbName = 'BIGSERIAL';
+    }
+    selectStrategy(value) {
+        return value ? BigInt(value) : undefined;
+    }
+}
+exports.PgBigSerial64 = PgBigSerial64;

package/dist/src/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;
+}

package/dist/src/columns/types/pgBoolean.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 columnType_1 = __importDefault(require("./columnType"));
+class PgBoolean extends columnType_1.default {
+    constructor() {
+        super();
+        this.getDbName = () => this.dbName;
+        this.insertStrategy = (value) => `${value}`;
+        this.dbName = 'boolean';
+    }
+    selectStrategy(value) {
+        return value;
+    }
+}
+exports.default = PgBoolean;

package/dist/src/columns/types/pgEnum.d.ts

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

package/dist/src/columns/types/pgEnum.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 columnType_1 = __importDefault(require("./columnType"));
+class PgEnum extends columnType_1.default {
+    constructor(dbName) {
+        super();
+        this.getDbName = () => this.dbName;
+        this.insertStrategy = (value) => `${value}`;
+        this.dbName = dbName;
+    }
+    selectStrategy(value) {
+        return value;
+    }
+}
+exports.default = PgEnum;