drizzle-orm 0.9.9 → 0.9.13

package/builders/highLvlBuilders/abstractRequestBuilder.d.ts

@@ -1,18 +1,18 @@
 import { AbstractColumn } from '../../columns/column';
 import ColumnType from '../../columns/types/columnType';
-import Session from '../../db/session';
+import { ISession } from '../../db/session';
 import BaseLogger from '../../logger/abstractLogger';
 import { AbstractTable } from '../../tables';
 import { ExtractModel } from '../../tables/inferTypes';
 export default abstract class TableRequestBuilder<TTable extends AbstractTable<TTable>> {
     protected _table: TTable;
-    protected _session: Session;
+    protected _session: ISession;
     protected _mappedServiceToDb: {
         [name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>;
     };
     protected _columns: AbstractColumn<ColumnType>[];
     protected _logger?: BaseLogger;
-    constructor(table: AbstractTable<TTable>, session: Session, mappedServiceToDb: {
+    constructor(table: AbstractTable<TTable>, session: ISession, mappedServiceToDb: {
         [name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>;
     }, logger?: BaseLogger);
     all: () => Promise<Array<ExtractModel<TTable> | undefined>>;

package/builders/highLvlBuilders/deleteRequestBuilder.d.ts

@@ -1,6 +1,6 @@
 import { AbstractColumn } from '../../columns/column';
 import ColumnType from '../../columns/types/columnType';
-import Session from '../../db/session';
+import { ISession } from '../../db/session';
 import BaseLogger from '../../logger/abstractLogger';
 import { AbstractTable } from '../../tables';
 import { ExtractModel } from '../../tables/inferTypes';
@@ -8,7 +8,7 @@ import Expr from '../requestBuilders/where/where';
 import TableRequestBuilder from './abstractRequestBuilder';
 export default class DeleteTRB<TTable extends AbstractTable<TTable>> extends TableRequestBuilder<TTable> {
     private _filter;
-    constructor(table: AbstractTable<TTable>, session: Session, mappedServiceToDb: {
+    constructor(table: AbstractTable<TTable>, session: ISession, mappedServiceToDb: {
         [name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>;
     }, logger?: BaseLogger);
     where: (expr: Expr) => DeleteTRB<TTable>;

package/builders/highLvlBuilders/deleteRequestBuilder.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const builderError_1 = require("../../errors/builderError");
-const dbErrors_1 = require("../../errors/dbErrors");
 const responseMapper_1 = require("../../mappers/responseMapper");
 const delete_1 = require("../lowLvlBuilders/delets/delete");
 const abstractRequestBuilder_1 = require("./abstractRequestBuilder");
@@ -30,13 +29,7 @@ class DeleteTRB extends abstractRequestBuilder_1.default {
                 this._logger.info(`Deleting from ${this._table.tableName()} using query:\n ${query}`);
             }
             const result = await this._session.execute(query);
-            if (result.isLeft()) {
-                const { reason } = result.value;
-                throw new dbErrors_1.DatabaseDeleteError(this._table.tableName(), reason, query);
-            }
-            else {
-                return responseMapper_1.default.map(this._mappedServiceToDb, result.value);
-            }
+            return responseMapper_1.default.map(this._mappedServiceToDb, result);
         };
     }
 }

package/builders/highLvlBuilders/insertRequestBuilder.d.ts

@@ -1,6 +1,6 @@
 import { AbstractColumn } from '../../columns/column';
 import ColumnType from '../../columns/types/columnType';
-import Session from '../../db/session';
+import { ISession } from '../../db/session';
 import BaseLogger from '../../logger/abstractLogger';
 import { AbstractTable } from '../../tables';
 import { ExtractModel, Indexing } from '../../tables/inferTypes';
@@ -9,7 +9,7 @@ export default class InsertTRB<TTable extends AbstractTable<TTable>> extends Tab
     private _values;
     private _onConflict;
     private _onConflictField;
-    constructor(values: ExtractModel<TTable>[], session: Session, mappedServiceToDb: {
+    constructor(values: ExtractModel<TTable>[], session: ISession, mappedServiceToDb: {
         [name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>;
     }, table: AbstractTable<TTable>, logger?: BaseLogger);
     execute: () => Promise<void>;

package/builders/highLvlBuilders/insertRequestBuilder.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const __1 = require("..");
 const builderError_1 = require("../../errors/builderError");
-const dbErrors_1 = require("../../errors/dbErrors");
 const responseMapper_1 = require("../../mappers/responseMapper");
 const insert_1 = require("../lowLvlBuilders/inserts/insert");
 const abstractRequestBuilder_1 = require("./abstractRequestBuilder");
@@ -40,13 +39,7 @@ class InsertTRB extends abstractRequestBuilder_1.default {
                 this._logger.info(`Inserting to ${this._table.tableName()} using query:\n ${query}`);
             }
             const result = await this._session.execute(query);
-            if (result.isLeft()) {
-                const { reason } = result.value;
-                throw new dbErrors_1.DatabaseInsertError(this._table.tableName(), reason, query);
-            }
-            else {
-                return responseMapper_1.default.map(this._mappedServiceToDb, result.value);
-            }
+            return responseMapper_1.default.map(this._mappedServiceToDb, result);
         };
         this._values = values;
     }

package/builders/highLvlBuilders/selectRequestBuilder.d.ts

@@ -1,7 +1,7 @@
 import { AbstractColumn } from '../../columns/column';
 import ColumnType from '../../columns/types/columnType';
 import DB from '../../db/db';
-import Session from '../../db/session';
+import { ISession } from '../../db/session';
 import BaseLogger from '../../logger/abstractLogger';
 import { AbstractTable } from '../../tables';
 import { ExtractModel } from '../../tables/inferTypes';
@@ -16,7 +16,7 @@ export default class SelectTRB<TTable extends AbstractTable<TTable>> extends Tab
     private __groupBy?;
     private __order?;
     private __distinct;
-    constructor(session: Session, mappedServiceToDb: {
+    constructor(session: ISession, mappedServiceToDb: {
         [name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>;
     }, props: {
         limit?: number;

package/builders/highLvlBuilders/selectRequestBuilder.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 /* eslint-disable import/no-cycle */
 const __1 = require("..");
 const builderError_1 = require("../../errors/builderError");
-const dbErrors_1 = require("../../errors/dbErrors");
 const responseMapper_1 = require("../../mappers/responseMapper");
 const selectWithJoin_1 = require("../joinBuilders/builders/selectWithJoin");
 const join_1 = require("../joinBuilders/join");
@@ -43,13 +42,7 @@ class SelectTRB extends abstractRequestBuilder_1.default {
                 this._logger.info(`Selecting from ${this._table.tableName()} using query:\n ${query}`);
             }
             const result = await this._session.execute(query);
-            if (result.isLeft()) {
-                const { reason } = result.value;
-                throw new dbErrors_1.DatabaseSelectError(this._table.tableName(), reason, query);
-            }
-            else {
-                return responseMapper_1.default.map(this._mappedServiceToDb, result.value);
-            }
+            return responseMapper_1.default.map(this._mappedServiceToDb, result);
         };
         this.props = props;
     }

package/builders/highLvlBuilders/updateRequestBuilder.d.ts

@@ -1,6 +1,6 @@
 import { AbstractColumn } from '../../columns/column';
 import ColumnType from '../../columns/types/columnType';
-import Session from '../../db/session';
+import { ISession } from '../../db/session';
 import BaseLogger from '../../logger/abstractLogger';
 import { AbstractTable } from '../../tables';
 import { ExtractModel, ExtractUpdateModel } from '../../tables/inferTypes';
@@ -10,7 +10,7 @@ export default class UpdateTRB<TTable extends AbstractTable<TTable>> extends Tab
     private _filter;
     private _update;
     private _objToUpdate;
-    constructor(table: AbstractTable<TTable>, session: Session, mappedServiceToDb: {
+    constructor(table: AbstractTable<TTable>, session: ISession, mappedServiceToDb: {
         [name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>;
     }, logger?: BaseLogger);
     where: (expr: Expr) => UpdateTRB<TTable>;

package/builders/highLvlBuilders/updateRequestBuilder.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const builderError_1 = require("../../errors/builderError");
-const dbErrors_1 = require("../../errors/dbErrors");
 const responseMapper_1 = require("../../mappers/responseMapper");
 const update_1 = require("../lowLvlBuilders/updates/update");
 const static_1 = require("../requestBuilders/updates/static");
@@ -48,13 +47,7 @@ class UpdateTRB extends abstractRequestBuilder_1.default {
                 this._logger.info(`Updating ${this._table.tableName()} using query:\n ${query}`);
             }
             const result = await this._session.execute(query);
-            if (result.isLeft()) {
-                const { reason } = result.value;
-                throw new dbErrors_1.DatabaseUpdateError(this._table.tableName(), reason, query);
-            }
-            else {
-                return responseMapper_1.default.map(this._mappedServiceToDb, result.value);
-            }
+            return responseMapper_1.default.map(this._mappedServiceToDb, result);
         };
     }
 }

package/builders/joinBuilders/builders/abstractJoinBuilder.d.ts

@@ -1,14 +1,14 @@
 import { QueryResult } from 'pg';
 import { AbstractColumn } from '../../../columns/column';
 import ColumnType from '../../../columns/types/columnType';
-import Session from '../../../db/session';
+import { ISession } from '../../../db/session';
 import { AbstractTable } from '../../../tables';
 import Order from '../../highLvlBuilders/order';
 import Expr from '../../requestBuilders/where/where';
 import Join from '../join';
 export default abstract class AbstractJoined<TTable extends AbstractTable<TTable>, TRes> {
     protected _table: TTable;
-    protected _session: Session;
+    protected _session: ISession;
     protected _filter: Expr;
     protected _distinct?: AbstractColumn<ColumnType, boolean, boolean>;
     protected _props: {
@@ -17,7 +17,7 @@ export default abstract class AbstractJoined<TTable extends AbstractTable<TTable
     };
     protected _orderBy?: AbstractColumn<ColumnType, boolean, boolean>;
     protected _order?: Order;
-    constructor(table: TTable, filter: Expr, session: Session, props: {
+    constructor(table: TTable, filter: Expr, session: ISession, props: {
         limit?: number;
         offset?: number;
     }, orderBy?: AbstractColumn<ColumnType, boolean, boolean>, order?: Order, distinct?: AbstractColumn<ColumnType, boolean, boolean>);

package/builders/joinBuilders/builders/abstractJoinBuilder.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const builderError_1 = require("../../../errors/builderError");
-const dbErrors_1 = require("../../../errors/dbErrors");
 const select_1 = require("../../lowLvlBuilders/selects/select");
 class AbstractJoined {
     constructor(table, filter, session, props, orderBy, order, distinct) {
@@ -22,13 +21,7 @@ class AbstractJoined {
                 throw new builderError_1.default(builderError_1.BuilderType.JOINED_SELECT, this._table.tableName(), Object.values(this._table.mapServiceToDb()), e, this._filter);
             }
             const result = await this._session.execute(query);
-            if (result.isLeft()) {
-                const { reason } = result.value;
-                throw new dbErrors_1.DatabaseSelectError(this._table.tableName(), reason, query);
-            }
-            else {
-                return this.mapResponse(result.value);
-            }
+            return this.mapResponse(result);
         };
         this._table = table;
         this._session = session;

package/builders/joinBuilders/builders/selectWithFiveJoins.d.ts

@@ -1,7 +1,7 @@
 import { QueryResult } from 'pg';
 import { AbstractColumn } from '../../../columns/column';
 import ColumnType from '../../../columns/types/columnType';
-import Session from '../../../db/session';
+import { ISession } from '../../../db/session';
 import { AbstractTable } from '../../../tables';
 import Order from '../../highLvlBuilders/order';
 import Expr from '../../requestBuilders/where/where';
@@ -14,7 +14,7 @@ export default class SelectTRBWithFiveJoins<TTable extends AbstractTable<TTable>
     private _join3;
     private _join4;
     private _join5;
-    constructor(table: TTable, session: Session, filter: Expr, join1: Join<TTable1>, join2: Join<TTable2>, join3: Join<TTable3>, join4: Join<TTable4>, join5: Join<TTable5>, props: {
+    constructor(table: TTable, session: ISession, filter: Expr, join1: Join<TTable1>, join2: Join<TTable2>, join3: Join<TTable3>, join4: Join<TTable4>, join5: Join<TTable5>, props: {
         limit?: number;
         offset?: number;
     }, orderBy?: AbstractColumn<ColumnType, boolean, boolean>, order?: Order, distinct?: AbstractColumn<ColumnType, boolean, boolean>);

package/builders/joinBuilders/builders/selectWithFourJoins.d.ts

@@ -2,7 +2,7 @@ import { QueryResult } from 'pg';
 import { AbstractColumn } from '../../../columns/column';
 import ColumnType from '../../../columns/types/columnType';
 import DB from '../../../db/db';
-import Session from '../../../db/session';
+import { ISession } from '../../../db/session';
 import { AbstractTable } from '../../../tables';
 import Order from '../../highLvlBuilders/order';
 import Expr from '../../requestBuilders/where/where';
@@ -15,7 +15,7 @@ export default class SelectTRBWithFourJoins<TTable extends AbstractTable<TTable>
     private _join2;
     private _join3;
     private _join4;
-    constructor(table: TTable, session: Session, filter: Expr, join1: Join<TTable1>, join2: Join<TTable2>, join3: Join<TTable3>, join4: Join<TTable4>, props: {
+    constructor(table: TTable, session: ISession, filter: Expr, join1: Join<TTable1>, join2: Join<TTable2>, join3: Join<TTable3>, join4: Join<TTable4>, props: {
         limit?: number;
         offset?: number;
     }, orderBy?: AbstractColumn<ColumnType, boolean, boolean>, order?: Order, distinct?: AbstractColumn<ColumnType, boolean, boolean>);

package/builders/joinBuilders/builders/selectWithJoin.d.ts

@@ -2,7 +2,7 @@ import { QueryResult } from 'pg';
 import { AbstractColumn } from '../../../columns/column';
 import ColumnType from '../../../columns/types/columnType';
 import DB from '../../../db/db';
-import Session from '../../../db/session';
+import { ISession } from '../../../db/session';
 import AbstractTable from '../../../tables/abstractTable';
 import Order from '../../highLvlBuilders/order';
 import Expr from '../../requestBuilders/where/where';
@@ -12,7 +12,7 @@ import AbstractJoined from './abstractJoinBuilder';
 import SelectTRBWithTwoJoins from './selectWithTwoJoins';
 export default class SelectTRBWithJoin<TTable extends AbstractTable<TTable>, TTable1> extends AbstractJoined<TTable, SelectResponseJoin<TTable, TTable1>> {
     private _join;
-    constructor(table: TTable, session: Session, filter: Expr, join: Join<TTable1>, props: {
+    constructor(table: TTable, session: ISession, filter: Expr, join: Join<TTable1>, props: {
         limit?: number;
         offset?: number;
     }, orderBy?: AbstractColumn<ColumnType, boolean, boolean>, order?: Order, distinct?: AbstractColumn<ColumnType, boolean, boolean>);

package/builders/joinBuilders/builders/selectWithThreeJoins.d.ts

@@ -2,7 +2,7 @@ import { QueryResult } from 'pg';
 import { AbstractColumn } from '../../../columns/column';
 import ColumnType from '../../../columns/types/columnType';
 import DB from '../../../db/db';
-import Session from '../../../db/session';
+import { ISession } from '../../../db/session';
 import AbstractTable from '../../../tables/abstractTable';
 import Order from '../../highLvlBuilders/order';
 import Expr from '../../requestBuilders/where/where';
@@ -14,7 +14,7 @@ export default class SelectTRBWithThreeJoins<TTable extends AbstractTable<TTable
     private _join1;
     private _join2;
     private _join3;
-    constructor(table: TTable, session: Session, filter: Expr, join1: Join<TTable1>, join2: Join<TTable2>, join3: Join<TTable3>, props: {
+    constructor(table: TTable, session: ISession, filter: Expr, join1: Join<TTable1>, join2: Join<TTable2>, join3: Join<TTable3>, props: {
         limit?: number;
         offset?: number;
     }, orderBy?: AbstractColumn<ColumnType, boolean, boolean>, order?: Order, distinct?: AbstractColumn<ColumnType, boolean, boolean>);

package/builders/joinBuilders/builders/selectWithTwoJoins.d.ts

@@ -2,7 +2,7 @@ import { QueryResult } from 'pg';
 import { AbstractColumn } from '../../../columns/column';
 import ColumnType from '../../../columns/types/columnType';
 import DB from '../../../db/db';
-import Session from '../../../db/session';
+import { ISession } from '../../../db/session';
 import AbstractTable from '../../../tables/abstractTable';
 import Order from '../../highLvlBuilders/order';
 import Expr from '../../requestBuilders/where/where';
@@ -13,7 +13,7 @@ import SelectTRBWithThreeJoins from './selectWithThreeJoins';
 export default class SelectTRBWithTwoJoins<TTable extends AbstractTable<TTable>, TTable1, TTable2> extends AbstractJoined<TTable, SelectResponseTwoJoins<TTable, TTable1, TTable2>> {
     private _join1;
     private _join2;
-    constructor(table: TTable, session: Session, filter: Expr, join1: Join<TTable1>, join2: Join<TTable2>, props: {
+    constructor(table: TTable, session: ISession, filter: Expr, join1: Join<TTable1>, join2: Join<TTable2>, props: {
         limit?: number;
         offset?: number;
     }, orderBy?: AbstractColumn<ColumnType, boolean, boolean>, order?: Order, distinct?: AbstractColumn<ColumnType, boolean, boolean>);

package/builders/transaction/transaction.d.ts

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

package/columns/types/columnType.d.ts

@@ -3,5 +3,5 @@ export default abstract class ColumnType<TCodeType = {}> {
     protected abstract dbName: string;
     abstract getDbName(): string;
     abstract insertStrategy(value: TCodeType): string;
-    abstract selectStrategy(value: any): TCodeType;
+    abstract selectStrategy(value: any): TCodeType | undefined;
 }

package/columns/types/pgBigDecimal.d.ts

@@ -6,5 +6,5 @@ export default class PgBigDecimal extends ColumnType<number> {
     constructor(precision?: number, scale?: number);
     getDbName: () => string;
     insertStrategy: (value: number) => string;
-    selectStrategy(value: string): number;
+    selectStrategy(value: string): number | undefined;
 }

package/columns/types/pgBigDecimal.js

@@ -22,7 +22,7 @@ class PgBigDecimal extends columnType_1.default {
         }
     }
     selectStrategy(value) {
-        return parseFloat(value);
+        return value ? parseFloat(value) : undefined;
     }
 }
 exports.default = PgBigDecimal;

package/columns/types/pgBigInt.d.ts

@@ -4,5 +4,5 @@ export default class PgBigInt extends ColumnType<number> {
     constructor();
     getDbName(): string;
     insertStrategy: (value: number) => string;
-    selectStrategy(value: string): number;
+    selectStrategy(value: string): number | undefined;
 }

package/columns/types/pgBigInt.js

@@ -11,7 +11,7 @@ class PgBigInt extends columnType_1.default {
         return this.dbName;
     }
     selectStrategy(value) {
-        return parseInt(value, 10);
+        return value ? parseInt(value, 10) : undefined;
     }
 }
 exports.default = PgBigInt;

package/columns/types/pgInteger.d.ts

@@ -4,5 +4,5 @@ export default class PgInteger extends ColumnType<number> {
     constructor();
     getDbName: () => string;
     insertStrategy: (value: number) => string;
-    selectStrategy(value: string): number;
+    selectStrategy(value: string): number | undefined;
 }

package/columns/types/pgInteger.js

@@ -9,7 +9,7 @@ class PgInteger extends columnType_1.default {
         this.dbName = 'INT';
     }
     selectStrategy(value) {
-        return parseInt(value, 10);
+        return value ? parseInt(value, 10) : undefined;
     }
 }
 exports.default = PgInteger;

package/columns/types/pgSmallInt.d.ts

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

package/columns/types/pgSmallInt.js

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

package/db/db.d.ts

@@ -1,19 +1,18 @@
-import { Pool } from 'pg';
 import BaseLogger from '../logger/abstractLogger';
 import { AbstractTable } from '../tables';
-import Session from './session';
+import { ISession } from './session';
 export declare type TableConstructor = {
     new (db: DB): AbstractTable<any>;
 };
 export default class DB {
-    private _session;
-    private _logger?;
-    private _cache;
-    constructor(pool: Pool);
+    protected _session: ISession;
+    protected _logger?: BaseLogger;
+    protected _cache: Map<TableConstructor, AbstractTable<any>>;
+    constructor(session: ISession);
     create<TTable extends AbstractTable<TTable>>(t: new (db: DB) => TTable): TTable;
     useLogger: (logger: BaseLogger) => void;
     cache: () => Map<TableConstructor, AbstractTable<any>>;
     logger: () => BaseLogger | undefined;
-    session: () => Session;
+    session: () => ISession;
     protected instanceFor<TTable extends AbstractTable<TTable>>(t: new (db: DB) => TTable): AbstractTable<any> | undefined;
 }

package/db/db.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const session_1 = require("./session");
 class DB {
-    constructor(pool) {
+    constructor(session) {
         this._cache = new Map();
         this.useLogger = (logger) => {
             this._logger = logger;
@@ -10,7 +9,7 @@ class DB {
         this.cache = () => this._cache;
         this.logger = () => this._logger;
         this.session = () => this._session;
-        this._session = new session_1.default(pool);
+        this._session = session;
     }
     create(t) {
         if (!this._cache.has(t)) {

package/db/dbConnector.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const pg_1 = require("pg");
 const db_1 = require("./db");
 const dbStringConnector_1 = require("./dbStringConnector");
+const session_1 = require("./session");
 class DbConnector {
     constructor() {
         this.connectionString = (url) => new dbStringConnector_1.default(url);
@@ -16,7 +17,7 @@ class DbConnector {
                 await pool.connect();
                 // console.log('Db connected!');
                 // check if table structure is the same as in code
-                return new db_1.default(pool);
+                return new db_1.default(new session_1.default(pool));
             }
             catch (e) {
                 // console.log(`Connection error: ${e.message}`);

package/db/dbStringConnector.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const pg_1 = require("pg");
 const db_1 = require("./db");
+const session_1 = require("./session");
 class DBStringConnector {
     constructor(url) {
         this.connect = async () => {
@@ -12,7 +13,7 @@ class DBStringConnector {
                 const pool = new pg_1.Pool(config);
                 await pool.connect();
                 // console.log('Db connected!');
-                return new db_1.default(pool);
+                return new db_1.default(new session_1.default(pool));
             }
             catch (e) {
                 // console.log(`Connection error: ${e.message}`);

package/db/session.d.ts

@@ -1,7 +1,9 @@
 import { Pool, QueryResult } from 'pg';
-import { Either, Failure } from '../errors/baseError';
-export default class Session {
+export declare abstract class ISession {
+    abstract execute(query: string): Promise<QueryResult<any>>;
+}
+export default class Session extends ISession {
     private pool;
     constructor(pool: Pool);
-    execute: (query: string) => Promise<Either<Failure, QueryResult<any>>>;
+    execute(query: string): Promise<QueryResult<any>>;
 }

package/db/session.js

@@ -1,20 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const baseError_1 = require("../errors/baseError");
-class Session {
+exports.ISession = void 0;
+class ISession {
+}
+exports.ISession = ISession;
+class Session extends ISession {
     constructor(pool) {
+        super();
         this.pool = pool;
-        this.execute = async (query) => {
-            try {
-                return baseError_1.right(await this.pool.query(query));
-            }
-            catch (e) {
-                return baseError_1.left({
-                    type: baseError_1.PgSessionError.PgQueryExecutionError,
-                    reason: e,
-                });
-            }
-        };
+    }
+    execute(query) {
+        return this.pool.query(query);
     }
 }
 exports.default = Session;

package/docs/cases/simple_insert.js

@@ -17,7 +17,7 @@ const usersTable_1 = require("../tables/usersTable");
         await usersTable.insert({
             decimalField: 12.4,
             createdAt: new Date(),
-            role: 'guest',
+            // role: 'guest',
         }).execute();
         const insertedCities = await citiesTable.insert({
             foundationDate: new Date(),
@@ -36,11 +36,11 @@ const usersTable_1 = require("../tables/usersTable");
         const conflictInsertedUsers = await usersTable.insertMany([{
                 decimalField: 12.4,
                 createdAt: new Date(),
-                role: 'guest',
+                // role: 'guest',
             }, {
                 decimalField: 32.4,
                 createdAt: new Date(),
-                role: 'admin',
+                // role: 'admin',
                 phone: '+1808',
             }])
             .onConflict((table) => table.phoneIndex, { isArchived: true }).all();

package/docs/cases/simple_join.js

@@ -24,11 +24,11 @@ const usersToUserGroups_1 = require("../tables/usersToUserGroups");
         const userRes = await usersTable.insertMany([{
                 decimalField: 4.2,
                 createdAt: new Date(),
-                role: 'guest',
+                // role: 'guest',
             }, {
                 decimalField: 5.8,
                 createdAt: new Date(),
-                role: 'user',
+                // role: 'user',
             }]).all();
         const citiesRes = await citiesTable.insertMany([{
                 foundationDate: new Date(),

package/docs/tables/usersTable.d.ts

@@ -7,7 +7,6 @@ export default class UsersTable extends AbstractTable<UsersTable> {
     media: import("../..").Column<import("../..").PgJsonb<string[]>, true, false>;
     decimalField: import("../..").Column<import("../..").PgBigDecimal, false, false>;
     bigIntField: import("../..").Column<import("../..").PgBigInt, true, false>;
-    role: import("../..").Column<import("../../columns/types/pgEnum").default<"user" | "guest" | "admin">, false, false>;
     createdAt: import("../..").Column<import("../..").PgTimestamp, false, false>;
     updatedAt: import("../..").Column<import("../..").PgTimestamp, true, false>;
     isArchived: import("../..").Column<import("../..").PgBoolean, true, false>;

package/docs/tables/usersTable.js

@@ -15,7 +15,7 @@ class UsersTable extends abstractTable_1.default {
         this.media = this.jsonb('media');
         this.decimalField = this.decimal('test', { notNull: true, precision: 100, scale: 2 });
         this.bigIntField = this.bigint('test1');
-        this.role = this.type(exports.rolesEnum, 'name_in_table', { notNull: true });
+        // public role = this.type(rolesEnum, 'name_in_table', { notNull: true });
         this.createdAt = this.timestamp('created_at', { notNull: true });
         this.updatedAt = this.timestamp('updated_at');
         this.isArchived = this.bool('is_archived').defaultValue(false);

package/index.d.ts

@@ -1,13 +1,9 @@
 import { ClientConfig } from 'pg';
 import { DB } from './db';
-import Migrator from './migrator/migrator';
-import AbstractTable from './tables/abstractTable';
 export * from './db';
 export * from './builders';
 export * from './columns';
 export * from './tables';
 export declare const drizzle: {
-    prepareCreateTable<TTable extends AbstractTable<TTable>>(table: AbstractTable<TTable>): string;
-    migrator(db: DB): Migrator;
     connect(config: ClientConfig): Promise<DB>;
 };

package/index.js

@@ -11,20 +11,12 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.drizzle = void 0;
-const create_1 = require("./builders/lowLvlBuilders/create");
 const db_1 = require("./db");
-const migrator_1 = require("./migrator/migrator");
 __exportStar(require("./db"), exports);
 __exportStar(require("./builders"), exports);
 __exportStar(require("./columns"), exports);
 __exportStar(require("./tables"), exports);
 exports.drizzle = {
-    prepareCreateTable(table) {
-        return create_1.default.table(table).build();
-    },
-    migrator(db) {
-        return new migrator_1.default(db);
-    },
     async connect(config) {
         const dbConnector = new db_1.DbConnector().params(config);
         return dbConnector.connect();

package/migrator/migrator.js

@@ -56,19 +56,13 @@ class Migrator {
                         if (logger) {
                             logger.info(`Executing migration with tag ${key} with query:\n${value}`);
                         }
-                        const result = await this._db.session().execute(value);
-                        if (result.isLeft()) {
-                            const { reason } = result.value;
-                            throw new Error(`Error while executing migration tag ${key}. Error: ${reason}`);
-                        }
-                        else {
-                            await migrationsTable
-                                .insert({
-                                version: key,
-                                createdAt: new Date(),
-                                hash: Buffer.from(value).toString('base64'),
-                            }).execute();
-                        }
+                        await this._db.session().execute(value);
+                        await migrationsTable
+                            .insert({
+                            version: key,
+                            createdAt: new Date(),
+                            hash: Buffer.from(value).toString('base64'),
+                        }).execute();
                     }
                     catch (e) {
                         await transaction.rollback();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drizzle-orm",
-  "version": "0.9.9",
+  "version": "0.9.13",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/tables/abstractTable.d.ts

@@ -63,6 +63,12 @@ export default abstract class AbstractTable<TTable extends AbstractTable<TTable>
     protected int(name: string, params: {
         notNull: true;
     }): Column<PgInteger, false>;
+    protected smallInt(name: string, params?: {
+        notNull: false;
+    }): Column<PgInteger, true>;
+    protected smallInt(name: string, params: {
+        notNull: true;
+    }): Column<PgInteger, false>;
     protected timestamp(name: string, params?: {
         notNull: false;
     }): Column<PgTimestamp, true>;

package/tables/abstractTable.js

@@ -16,6 +16,7 @@ const pgBigInt_1 = require("../columns/types/pgBigInt");
 const pgEnum_1 = require("../columns/types/pgEnum");
 const column_1 = require("../columns/column");
 const tableIndex_1 = require("../indexes/tableIndex");
+const pgSmallInt_1 = require("../columns/types/pgSmallInt");
 class AbstractTable {
     constructor(db) {
         this.withLogger = (logger) => {
@@ -79,6 +80,10 @@ class AbstractTable {
         var _a;
         return new column_1.Column(this, name, new pgInteger_1.default(), (_a = !(params === null || params === void 0 ? void 0 : params.notNull)) !== null && _a !== void 0 ? _a : false);
     }
+    smallInt(name, params = {}) {
+        var _a;
+        return new column_1.Column(this, name, new pgSmallInt_1.default(), (_a = !(params === null || params === void 0 ? void 0 : params.notNull)) !== null && _a !== void 0 ? _a : false);
+    }
     timestamp(name, params = {}) {
         var _a;
         return new column_1.Column(this, name, new pgTimestamp_1.default(), (_a = !(params === null || params === void 0 ? void 0 : params.notNull)) !== null && _a !== void 0 ? _a : false);

package/tables/index.d.ts

@@ -1,2 +1,3 @@
 export { default as MigrationsTable } from './migrationsTable';
 export { default as AbstractTable } from './abstractTable';
+export { ExtractModel } from './inferTypes';

package/test.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const _1 = require(".");
 // import { Pool } from 'pg';
 // import { DB } from '.';
 // import { DB, DbConnector } from '.';
@@ -17,14 +16,11 @@ const fromTypeFile = (filepath) => {
 };
 (async () => {
     try {
-        const db = await new _1.DbConnector()
-            .connectionString('postgresql://postgres@127.0.0.1/migrator')
-            .connect();
         // const ser = new MigrationSerializer();
         // const d = db.create(UsersTable) as unknown as AbstractTable<any>;
         // const f = ser.generate([d], []);
         // console.log(JSON.stringify(f, null, 2));
-        await _1.drizzle.migrator(db).migrate('src/drizzle.config.yaml');
+        // await drizzle.migrator(db).migrate('src/drizzle.config.yaml');
         // drizzle.migrator(db).migrate({ migrationFolder: '' });
         // const typesFileNames = fs.readdirSync('/Users/andrewsherman/IdeaProjects/datalayer-orm/src/examples/types');
         // typesFileNames.forEach((filename) => {
@@ -38,9 +34,36 @@ const fromTypeFile = (filepath) => {
         // const db = await new DbConnector()
         //   .connectionString('postgresql://postgres@127.0.0.1/drizzle')
         //   .connect();
-        // const res = await db.session().execute(
-        //   Create.table(db.create(UsersTable)).build(),
+        // const db = await new DbConnector()
+        //   .connectionString('postgresql://postgres@127.0.0.1/migrator')
+        //   .connect();
+        // const usersTable: UsersTable = new UsersTable(db);
+        // const knexInstance = knex.knex({
+        //   client: 'pg',
+        //   connection: 'postgresql://postgres@127.0.0.1/migrator',
+        // });
+        // const userTableForKnex: UsersTable = new UsersTable(knexDb);
+        // const users = await userTableForKnex.select().all();
+        // console.log(users[0]);
+        // const arr: AbstractColumn<ColumnType<any>, boolean, boolean>[] = [usersTable.id, usersTable.phone];
+        // const objectRes: {[name: string]: AbstractColumn<ColumnType, boolean, boolean>} = arr.reduce(
+        //   (obj, item, index) => Object.assign(obj, { [Object.getOwnPropertyNames(item)[index]]: item }), {},
         // );
+        // type f = ExtractModel<typeof objectRes1>;
+        // type d1 = ExtractModel<UsersTable>;
+        // const f = await usersTable.select()
+        //   .fieldsv2({
+        //     usersCount: count(usersTable.id),
+        //     sumNumber: sum(usersTable.phone),
+        //     role: usersTable.role,
+        //   });
+        // const objectRes1 = {
+        //   idid: usersTable.id,
+        //   pisun: usersTable.phone,
+        //   vau: usersTable.role,
+        // };
+        // type fd = ExtractModel<typeof objectRes1>;
+        // const g = await usersTable.select().execute();
         // if (res.isLeft()) {
         //   console.log(res.value.reason);
         // } else {