drizzle-orm 0.10.26 → 0.10.29

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

@@ -0,0 +1,37 @@
+import { shouldEcranate } from '../../../utils/ecranate';
+import Expr from './where';
+
+export default class ConstArray extends Expr {
+  private values: Array<any>;
+
+  public constructor(values: Array<any>) {
+    super();
+    this.values = values;
+  }
+
+  public toQuery = (position?: number): { query: string, values: Array<any> } => {
+    let nextPosition = position || 1;
+
+    const finalArray: string[] = [];
+    const finalValues: string[] = [];
+    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 (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 };
+  };
+}

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

@@ -0,0 +1,20 @@
+/* eslint-disable max-len */
+import Expr from './where';
+
+export default class EqWhere extends Expr {
+  private left: Expr;
+  private right: Expr;
+
+  public constructor(left: Expr, right: Expr) {
+    super();
+    this.left = left;
+    this.right = right;
+  }
+
+  public toQuery = (position?: number, tableCache?: {[tableName: string]: string}): { query: string, values: Array<any>} => {
+    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] };
+  };
+}

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

@@ -0,0 +1,20 @@
+/* eslint-disable max-len */
+import Expr from './where';
+
+export default class Greater extends Expr {
+  private left: Expr;
+  private right: Expr;
+
+  public constructor({ left, right }: { left: Expr; right: Expr; }) {
+    super();
+    this.left = left;
+    this.right = right;
+  }
+
+  public toQuery = (position: number, tableCache?: {[tableName: string]: string}): { query: string, values: Array<any> } => {
+    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] };
+  };
+}

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

@@ -0,0 +1,20 @@
+/* eslint-disable max-len */
+import Expr from './where';
+
+export default class GreaterEq extends Expr {
+  private left: Expr;
+  private right: Expr;
+
+  public constructor({ left, right }: { left: Expr; right: Expr; }) {
+    super();
+    this.left = left;
+    this.right = right;
+  }
+
+  public toQuery = (position: number, tableCache?: {[tableName: string]: string}): { query: string, values: Array<any> } => {
+    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] };
+  };
+}

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

@@ -0,0 +1,20 @@
+/* eslint-disable max-len */
+import Expr from './where';
+
+export default class In extends Expr {
+  private left: Expr;
+  private right: Expr;
+
+  public constructor(left: Expr, right: Expr) {
+    super();
+    this.left = left;
+    this.right = right;
+  }
+
+  public toQuery = (position?: number, tableCache?: {[tableName: string]: string}): { query: string, values: Array<any> } => {
+    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] };
+  };
+}

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

@@ -0,0 +1,17 @@
+/* eslint-disable max-len */
+import Expr from './where';
+
+export default class IsNotNull extends Expr {
+  private left: Expr;
+
+  public constructor(left: Expr) {
+    super();
+    this.left = left;
+  }
+
+  public toQuery = (position?: number, tableCache?: {[tableName: string]: string}): { query: string, values: Array<any> } => {
+    const leftPreparedValues = this.left.toQuery(position, tableCache);
+
+    return { query: `${leftPreparedValues.query} is not null`, values: leftPreparedValues.values };
+  };
+}

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

@@ -0,0 +1,17 @@
+/* eslint-disable max-len */
+import Expr from './where';
+
+export default class IsNull extends Expr {
+  private left: Expr;
+
+  public constructor(left: Expr) {
+    super();
+    this.left = left;
+  }
+
+  public toQuery = (position?: number, tableCache?: {[tableName: string]: string}): { query: string, values: Array<any> } => {
+    const leftPreparedValues = this.left.toQuery(position, tableCache);
+
+    return { query: `${leftPreparedValues.query} is null`, values: leftPreparedValues.values };
+  };
+}

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

@@ -0,0 +1,20 @@
+/* eslint-disable max-len */
+import Expr from './where';
+
+export default class Less extends Expr {
+  private left: Expr;
+  private right: Expr;
+
+  public constructor({ left, right }: { left: Expr; right: Expr; }) {
+    super();
+    this.left = left;
+    this.right = right;
+  }
+
+  public toQuery = (position?: number, tableCache?: {[tableName: string]: string}): { query: string, values: Array<any> } => {
+    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] };
+  };
+}

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

@@ -0,0 +1,20 @@
+/* eslint-disable max-len */
+import Expr from './where';
+
+export default class LessEq extends Expr {
+  private left: Expr;
+  private right: Expr;
+
+  public constructor({ left, right }: { left: Expr; right: Expr; }) {
+    super();
+    this.left = left;
+    this.right = right;
+  }
+
+  public toQuery = (position?: number, tableCache?: {[tableName: string]: string}): { query: string, values: Array<any> } => {
+    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] };
+  };
+}

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

@@ -0,0 +1,20 @@
+/* eslint-disable max-len */
+import Expr from './where';
+
+export default class Like extends Expr {
+  private left: Expr;
+  private right: Expr;
+
+  public constructor(left: Expr, right: Expr) {
+    super();
+    this.left = left;
+    this.right = right;
+  }
+
+  public toQuery = (position?: number, tableCache?: {[tableName: string]: string}): { query: string, values: Array<any> } => {
+    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] };
+  };
+}

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

@@ -0,0 +1,20 @@
+/* eslint-disable max-len */
+import Expr from './where';
+
+export default class NotEqWhere extends Expr {
+  private left: Expr;
+  private right: Expr;
+
+  public constructor(left: Expr, right: Expr) {
+    super();
+    this.left = left;
+    this.right = right;
+  }
+
+  public toQuery = (position?: number, tableCache?: {[tableName: string]: string}): { query: string, values: Array<any> } => {
+    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] };
+  };
+}

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

@@ -0,0 +1,35 @@
+/* eslint-disable max-len */
+import Expr from './where';
+
+export default class Or extends Expr {
+  private expressions: Expr[];
+
+  public constructor(expressions: Expr[]) {
+    super();
+    this.expressions = expressions;
+  }
+
+  public toQuery = (position?: number, tableCache?: {[tableName: string]: string}): { query: string, values: Array<any> } => {
+    let nextPosition = position || 1;
+
+    const result: string[] = ['('];
+    const valuesResult: Array<any> = [];
+    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 };
+  };
+}

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

@@ -0,0 +1,10 @@
+/* eslint-disable max-len */
+import Expr from './where';
+
+export default class RawWhere extends Expr {
+  public constructor(private custom: string) {
+    super();
+  }
+
+  public toQuery = (): { query: string, values: Array<any> } => ({ query: this.custom, values: [] });
+}

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

@@ -0,0 +1,60 @@
+import { AbstractColumn } from '../../../columns/column';
+import ColumnType from '../../../columns/types/columnType';
+import { ExtractCodeType } from '../../../tables/inferTypes';
+import And from './and';
+import Const from './const';
+import ConstArray from './constArray';
+import EqWhere from './eqWhere';
+import Greater from './greater';
+import GreaterEq from './greaterEq';
+import In from './in';
+import IsNotNull from './isNotNull';
+import IsNull from './isNull';
+import Less from './less';
+import LessEq from './lessEq';
+import Like from './like';
+import NotEqWhere from './notEqWhere';
+import Or from './or';
+import RawWhere from './rawWhere';
+import Var from './var';
+import Expr from './where';
+
+// eslint-disable-next-line max-len
+export const eq = <T extends AbstractColumn<ColumnType<any>, boolean, boolean>>(
+  left: T, value: ExtractCodeType<T>): Expr => new EqWhere(new Var<T>(left), new Const(value));
+
+export const raw = (customQuery: string): Expr => new RawWhere(customQuery);
+
+export const and = (expressions: Expr[]): Expr => new And(expressions);
+
+export const or = (expressions: Expr[]): Expr => new Or(expressions);
+
+export const like = <T extends AbstractColumn<ColumnType<any>, boolean, boolean>>(left: T,
+  value: ExtractCodeType<T>): Expr => new Like(new Var<T>(left), new Const(value));
+
+export const inArray = <T extends AbstractColumn<ColumnType<any>, boolean, boolean>>(left: T,
+  value: ExtractCodeType<T>[]): Expr => new In(new Var<T>(left), new ConstArray(value));
+
+export const greater = <T extends AbstractColumn<ColumnType<any>, boolean, boolean>>(left: T,
+  value: ExtractCodeType<T>)
+  : Expr => new Greater({ left: new Var<T>(left), right: new Const(value) });
+
+export const less = <T extends AbstractColumn<ColumnType<any>, boolean, boolean>>(left: T,
+  value: ExtractCodeType<T>): Expr => new Less({ left: new Var<T>(left), right: new Const(value) });
+
+export const greaterEq = <T extends AbstractColumn<ColumnType<any>, boolean, boolean>>(left: T,
+  value: ExtractCodeType<T>)
+  : Expr => new GreaterEq({ left: new Var<T>(left), right: new Const(value) });
+
+export const lessEq = <T extends AbstractColumn<ColumnType<any>, boolean, boolean>>(left: T,
+  value: ExtractCodeType<T>)
+  : Expr => new LessEq({ left: new Var<T>(left), right: new Const(value) });
+
+export const isNull = <T extends AbstractColumn<ColumnType<any>, boolean, boolean>>(
+  left: T): Expr => new IsNull(new Var<T>(left));
+
+export const isNotNull = <T extends AbstractColumn<ColumnType<any>, boolean, boolean>>(
+  left: T): Expr => new IsNotNull(new Var<T>(left));
+
+export const notEq = <T extends AbstractColumn<ColumnType<any>, boolean, boolean>>(
+  left: T, value: ExtractCodeType<T>): Expr => new NotEqWhere(new Var<T>(left), new Const(value));

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

@@ -0,0 +1,19 @@
+/* eslint-disable max-len */
+import { AbstractColumn } from '../../../columns/column';
+import ColumnType from '../../../columns/types/columnType';
+import { ecranate } from '../../../utils/ecranate';
+import Expr from './where';
+
+export default class Var<T extends AbstractColumn<ColumnType<any>, boolean, boolean>> extends Expr {
+  private column: T;
+
+  public constructor(column: T) {
+    super();
+    this.column = column;
+  }
+
+  public toQuery = (postition?: number, tableCache?: {[tableName: string]: string}): { query: string, values: Array<any> } => {
+    const tableName = tableCache && tableCache[this.column.getParentName()] ? tableCache[this.column.getParentName()] : this.column.getParentName();
+    return { query: `${tableName}.${ecranate(this.column.getColumnName())}`, values: [] };
+  };
+}

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

@@ -0,0 +1,5 @@
+/* eslint-disable max-classes-per-file */
+export default abstract class Expr {
+  abstract toQuery(position?: number, tableCache?: {[tableName: string]: string})
+  : { query: string, values: Array<any> };
+}

package/src/builders/transaction/transaction.ts

@@ -0,0 +1,21 @@
+import { ISession } from '../../db/session';
+
+export default class Transaction {
+  public constructor(private session: ISession) {
+  }
+
+  public begin = async (): Promise<Transaction> => {
+    await this.session.execute('BEGIN;');
+    return this;
+  };
+
+  public commit = async (): Promise<Transaction> => {
+    await this.session.execute('COMMIT;');
+    return this;
+  };
+
+  public rollback = async (): Promise<Transaction> => {
+    await this.session.execute('ROLLBACK;');
+    return this;
+  };
+}

package/src/columns/column.ts

@@ -0,0 +1,195 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable max-len */
+/* eslint-disable max-classes-per-file */
+import { PgTime, PgTimestamp } from '.';
+import DB from '../db/db';
+import CitiesTable from '../docs/tables/citiesTable';
+import UsersTable from '../docs/tables/usersTable';
+import { AbstractTable } from '../tables';
+import { shouldEcranate } from '../utils/ecranate';
+import ColumnType from './types/columnType';
+import PgTimestamptz from './types/pgTimestamptz';
+
+export enum Defaults {
+  CURRENT_TIMESTAMP = 'CURRENT_TIMESTAMP',
+}
+
+type PgTimes = PgTimestamptz | PgTime | PgTimestamp;
+
+export type ExtractColumnType<T extends ColumnType> =
+ T extends ColumnType<infer TCodeType> ?
+   T extends PgTimes ? TCodeType | Defaults : TCodeType
+   : never;
+
+// eslint-disable-next-line max-len
+export abstract class AbstractColumn<T extends ColumnType, TNullable extends boolean = true, TAutoIncrement extends boolean = false, TParent extends AbstractTable<any> = any> {
+  public isNullableFlag: boolean = true;
+  public primaryKeyName?: string;
+  public uniqueKeyName?: string;
+
+  protected onDelete?: string;
+  protected onUpdate?: string;
+  protected parent: TParent;
+
+  protected parentTableName: string;
+  protected columnType: T;
+  protected columnName: string;
+  protected defaultParam: any = null;
+  protected referenced: AbstractColumn<T, boolean, boolean>;
+
+  public constructor(parent: TParent, columnName: string,
+    columnType: T) {
+    this.columnType = columnType;
+    this.columnName = columnName;
+    this.parentTableName = parent.tableName();
+    this.parent = parent;
+  }
+
+  public getOnDelete = (): string | undefined => this.onDelete;
+  public getOnUpdate = (): string | undefined => this.onUpdate;
+
+  public getAlias = (): string => `${this.parentTableName.replace('.', '_')}_${this.columnName}`;
+
+  public getParent = (): AbstractTable<any> => this.parent;
+
+  public getParentName = (): string => this.parentTableName;
+
+  public 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>;
+
+  public 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>;
+
+  public defaultValue = (value: ExtractColumnType<T>) => {
+    if (Defaults[value as Defaults] !== undefined) {
+      this.defaultParam = value;
+    } else if (typeof value === 'boolean' || typeof value === 'number' || typeof value === 'bigint') {
+      this.defaultParam = value;
+    } else {
+      this.defaultParam = `'${value}'`;
+    }
+    return this;
+  };
+
+  public abstract primaryKey(): AbstractColumn<T, boolean, boolean, TParent>;
+
+  public unique = () => {
+    this.uniqueKeyName = this.columnName;
+    return this;
+  };
+
+  public abstract notNull(): AbstractColumn<T, boolean, boolean, TParent>;
+
+  public getColumnName = (): string => this.columnName;
+
+  public getReferenced = (): AbstractColumn<T, boolean, boolean, TParent> => this.referenced;
+
+  public getColumnType = (): T => this.columnType;
+
+  public getDefaultValue = (): any => this.defaultParam;
+}
+
+// eslint-disable-next-line max-len
+export class Column<T extends ColumnType, TNullable extends boolean = true, TAutoIncrement extends boolean = false, TParent extends AbstractTable<any> = any>
+  extends AbstractColumn<T, TNullable, TAutoIncrement, TParent> {
+  public constructor(parent: TParent, columnName: string,
+    columnType: T) {
+    super(parent, columnName, columnType);
+  }
+
+  public notNull(): Column<T, TAutoIncrement extends true ? true : TNullable extends true ? false : true, TAutoIncrement, TParent> {
+    this.isNullableFlag = false;
+    return this as Column<T, TAutoIncrement extends true ? true : TNullable extends true ? false : true, TAutoIncrement, TParent>;
+  }
+
+  public primaryKey(): Column<T, TAutoIncrement extends true ? true : false, TAutoIncrement, TParent> {
+    this.primaryKeyName = `${this.parentTableName}_${this.columnName}`;
+    return this as Column<T, TAutoIncrement extends true ? true : false, TAutoIncrement, TParent>;
+  }
+
+  public 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> {
+    const tableInstance: ITable = this.getParent().db.create(table);
+    this.referenced = callback(tableInstance);
+    this.onDelete = onConstraint?.onDelete ? `ON DELETE ${onConstraint.onDelete}` : undefined;
+    this.onUpdate = onConstraint?.onUpdate ? `ON UPDATE ${onConstraint.onUpdate}` : undefined;
+    return this;
+  }
+
+  public 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> {
+    this.referenced = column;
+    this.onDelete = onConstraint?.onDelete ? `ON DELETE ${onConstraint.onDelete}` : undefined;
+    this.onUpdate = onConstraint?.onUpdate ? `ON UPDATE ${onConstraint.onUpdate}` : undefined;
+    return this;
+  }
+}
+
+// eslint-disable-next-line max-len
+export class IndexedColumn<T extends ColumnType, TNullable extends boolean = true, TAutoIncrement extends boolean = false, TParent extends AbstractTable<any> = any> extends AbstractColumn<T, TNullable, TAutoIncrement, TParent> {
+  public constructor(parent: TParent, columnName: string,
+    columnType: T, nullable: TNullable) {
+    super(parent, columnName, columnType);
+  }
+
+  public notNull(): IndexedColumn<T, TAutoIncrement extends true ? true : TNullable extends true? false : true, TAutoIncrement, TParent> {
+    this.isNullableFlag = false;
+    return this as IndexedColumn<T, TAutoIncrement extends true ? true : TNullable extends true? false : true, TAutoIncrement, TParent>;
+  }
+
+  public primaryKey(): IndexedColumn<T, TAutoIncrement extends true ? true : false, TAutoIncrement, TParent> {
+    this.primaryKeyName = `${this.parentTableName}_${this.columnName}`;
+    // eslint-disable-next-line max-len
+    return this as IndexedColumn<T, TAutoIncrement extends true ? true : false, TAutoIncrement, TParent>;
+  }
+
+  public 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> {
+    // eslint-disable-next-line new-cap
+    this.referenced = callback(this.getParent().db.create(table));
+    this.onDelete = onConstraint?.onDelete ? `ON DELETE ${onConstraint.onDelete}` : undefined;
+    this.onUpdate = onConstraint?.onUpdate ? `ON UPDATE ${onConstraint.onUpdate}` : undefined;
+    return this;
+  }
+
+  public 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> {
+    this.referenced = column;
+    this.onDelete = onConstraint?.onDelete ? `ON DELETE ${onConstraint.onDelete}` : undefined;
+    this.onUpdate = onConstraint?.onUpdate ? `ON UPDATE ${onConstraint.onUpdate}` : undefined;
+    return this;
+  }
+}

package/src/columns/index.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/src/columns/types/columnType.ts

@@ -0,0 +1,8 @@
+// eslint-disable-next-line max-classes-per-file
+export default abstract class ColumnType<TCodeType = {}> {
+  public codeType: TCodeType;
+  protected abstract dbName: string;
+  abstract getDbName(): string;
+  abstract insertStrategy(value: TCodeType): string;
+  abstract selectStrategy(value: any): TCodeType | undefined;
+}

package/src/columns/types/pgBigDecimal.ts

@@ -0,0 +1,29 @@
+import ColumnType from './columnType';
+
+export default class PgBigDecimal extends ColumnType<number> {
+  public precision?: number;
+  public scale?: number;
+  public dbName: string;
+
+  public constructor(precision?: number, scale?: number) {
+    super();
+    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'; }
+  }
+
+  public getDbName = (): string => this.dbName;
+
+  public insertStrategy = (value: number): string => `${value}`;
+
+  public selectStrategy(value: string): number | undefined {
+    return value ? parseFloat(value) : undefined;
+  }
+}