drizzle-orm 0.9.0 → 0.9.4

package/src/builders/highLvlBuilders/selectRequestBuilder.ts

@@ -1,102 +0,0 @@
-import { Select } from '..';
-import { Column } from '../../columns/column';
-import ColumnType from '../../columns/types/columnType';
-import Session from '../../db/session';
-import BuilderError, { BuilderType } from '../../errors/builderError';
-import { DatabaseSelectError } from '../../errors/dbErrors';
-import BaseLogger from '../../logger/abstractLogger';
-import QueryResponseMapper from '../../mappers/responseMapper';
-import { AbstractTable } from '../../tables';
-import { ExtractModel } from '../../tables/inferTypes';
-import SelectTRBWithJoin from '../joinBuilders/builders/selectWithJoin';
-import Join from '../joinBuilders/join';
-import Expr from '../requestBuilders/where/where';
-import TableRequestBuilder from './abstractRequestBuilder';
-import Order from './order';
-
-export default class SelectTRB<TTable>
-  extends TableRequestBuilder<TTable> {
-  protected _filter: Expr;
-  private props: {limit?:number, offset?:number};
-  private __orderBy?: Column<ColumnType, boolean, boolean>;
-  private __groupBy?: Column<ColumnType, boolean, boolean>;
-  private __order?: Order;
-  private __table: TTable;
-
-  public constructor(
-    tableName: string,
-    session: Session,
-    mappedServiceToDb: { [name in keyof ExtractModel<TTable>]: Column<ColumnType>; },
-    logger: BaseLogger,
-    props: {limit?:number, offset?:number},
-    table: AbstractTable<TTable>,
-  ) {
-    super(tableName, session, mappedServiceToDb, logger);
-    this.props = props;
-    this.__table = table as unknown as TTable;
-  }
-
-  public where = (expr: Expr): SelectTRB<TTable> => {
-    this._filter = expr;
-    return this;
-  };
-
-  public orderBy(callback: (table: TTable) => Column<ColumnType, boolean, boolean>, order: Order)
-    : SelectTRB<TTable> {
-    this.__orderBy = callback(this.__table);
-    this.__order = order;
-    console.log(this.__orderBy, this.__order);
-    return this;
-  }
-
-  // public groupBy(callback: (table: TTable) => Column<ColumnType, boolean, boolean>)
-  //   : SelectTRB<TTable> {
-  //   this.__groupBy = callback(this.__table);
-  //   return this;
-  // }
-
-  public join = <COLUMN extends ColumnType, T1>(join: Join<COLUMN, T1>):
-  SelectTRBWithJoin<COLUMN, T1, TTable> => new SelectTRBWithJoin(this._tableName, this._session,
-    this._filter, join, this._mappedServiceToDb);
-
-  public execute = async () => {
-    const res = await this._execute();
-    return res;
-  };
-
-  protected _execute = async (): Promise<ExtractModel<TTable>[]> => {
-    // Select.from().filteredBy().limit().offset().orderBy().groupBy().build()
-    const queryBuilder = Select.from(this._tableName, this._columns);
-    if (this._filter) {
-      queryBuilder.filteredBy(this._filter);
-    }
-    if (this.props.limit) {
-      queryBuilder.limit(this.props.limit);
-    }
-    if (this.props.offset) {
-      queryBuilder.offset(this.props.offset);
-    }
-    if (this.__orderBy) {
-      queryBuilder.orderBy(this.__orderBy, this.__order!);
-    }
-
-    let query = '';
-    try {
-      query = queryBuilder.build();
-    } catch (e) {
-      throw new BuilderError(BuilderType.SELECT, this._tableName, this._columns, e, this._filter);
-    }
-
-    if (this._logger) {
-      this._logger.info(`Selecting from ${this._tableName} using query:\n ${query}`);
-    }
-
-    const result = await this._session.execute(query);
-    if (result.isLeft()) {
-      const { reason } = result.value;
-      throw new DatabaseSelectError(this._tableName, reason, query);
-    } else {
-      return QueryResponseMapper.map(this._mappedServiceToDb, result.value);
-    }
-  };
-}

package/src/builders/highLvlBuilders/updateRequestBuilder.ts

@@ -1,63 +0,0 @@
-import { Column } from '../../columns/column';
-import ColumnType from '../../columns/types/columnType';
-import Session from '../../db/session';
-import BuilderError, { BuilderType } from '../../errors/builderError';
-import { DatabaseUpdateError } from '../../errors/dbErrors';
-import BaseLogger from '../../logger/abstractLogger';
-import QueryResponseMapper from '../../mappers/responseMapper';
-import { ExtractModel } from '../../tables/inferTypes';
-import Update from '../lowLvlBuilders/updates/update';
-import UpdateExpr from '../requestBuilders/updates/updates';
-import Expr from '../requestBuilders/where/where';
-import TableRequestBuilder from './abstractRequestBuilder';
-
-export default class UpdateTRB<TTable> extends TableRequestBuilder<TTable> {
-  private _filter: Expr;
-  private _update: UpdateExpr;
-
-  public constructor(
-    tableName: string,
-    session: Session,
-    mappedServiceToDb: { [name in keyof ExtractModel<TTable>]: Column<ColumnType>; },
-    logger: BaseLogger,
-  ) {
-    super(tableName, session, mappedServiceToDb, logger);
-  }
-
-  public where = (expr: Expr): UpdateTRB<TTable> => {
-    this._filter = expr;
-    return this;
-  };
-
-  public set = (expr: UpdateExpr): UpdateTRB<TTable> => {
-    this._update = expr;
-    return this;
-  };
-
-  public execute = async () => {
-    await this._execute();
-  };
-
-  protected _execute = async (): Promise<ExtractModel<TTable>[]> => {
-    let query = '';
-    try {
-      query = Update.in(this._tableName)
-        .columns(this._columns)
-        .set(this._update).filteredBy(this._filter)
-        .build();
-    } catch (e) {
-      throw new BuilderError(BuilderType.UPDATE, this._tableName, this._columns, e, this._filter);
-    }
-
-    if (this._logger) {
-      this._logger.info(`Updating ${this._tableName} using query:\n ${query}`);
-    }
-    const result = await this._session.execute(query);
-    if (result.isLeft()) {
-      const { reason } = result.value;
-      throw new DatabaseUpdateError(this._tableName, reason, query);
-    } else {
-      return QueryResponseMapper.map(this._mappedServiceToDb, result.value);
-    }
-  };
-}

package/src/builders/joinBuilders/builders/abstractJoinBuilder.ts

@@ -1,22 +0,0 @@
-import { Column } from '../../../columns/column';
-import ColumnType from '../../../columns/types/columnType';
-import Session from '../../../db/session';
-import { ExtractModel } from '../../../tables/inferTypes';
-import Expr from '../../requestBuilders/where/where';
-
-export default abstract class AbstractJoined<K> {
-  protected _tableName: string;
-  protected _session: Session;
-  protected _filter: Expr;
-  protected _columns: { [name in keyof ExtractModel<K>]: Column<ColumnType>; };
-
-  public constructor(filter: Expr,
-    tableName: string,
-    session: Session,
-    columns: { [name in keyof ExtractModel<K>]: Column<ColumnType>; }) {
-    this._tableName = tableName;
-    this._session = session;
-    this._filter = filter;
-    this._columns = columns;
-  }
-}

package/src/builders/joinBuilders/builders/selectWithFourJoins.ts

@@ -1,71 +0,0 @@
-import { Column } from '../../../columns/column';
-import ColumnType from '../../../columns/types/columnType';
-import Session from '../../../db/session';
-import BuilderError, { BuilderType } from '../../../errors/builderError';
-import { DatabaseSelectError } from '../../../errors/dbErrors';
-import QueryResponseMapper from '../../../mappers/responseMapper';
-import { ExtractModel } from '../../../tables/inferTypes';
-import Select from '../../lowLvlBuilders/selects/select';
-import Expr from '../../requestBuilders/where/where';
-import Join from '../join';
-import SelectResponseFourJoins from '../responses/selectResponseFourJoins';
-import AbstractJoined from './abstractJoinBuilder';
-
-export default class SelectTRBWithFourJoins<COLUMN extends
-ColumnType, T1, T2, T3, T4, MODEL> extends AbstractJoined<MODEL> {
-  private _join1: Join<COLUMN, T1>;
-  private _join2: Join<COLUMN, T2>;
-  private _join3: Join<COLUMN, T3>;
-  private _join4: Join<COLUMN, T4>;
-
-  public constructor(tableName: string, session: Session,
-    filter: Expr, join1: Join<COLUMN, T1>, join2: Join<COLUMN, T2>, join3: Join<COLUMN, T3>,
-    join4: Join<COLUMN, T4>,
-    columns: { [name in keyof ExtractModel<MODEL>]: Column<ColumnType>; }) {
-    super(filter, tableName, session, columns);
-    this._join1 = join1;
-    this._join2 = join2;
-    this._join3 = join3;
-    this._join4 = join4;
-  }
-
-  public execute = async (): Promise<SelectResponseFourJoins<MODEL, T1, T2, T3, T4>> => {
-    const queryBuilder = Select.from(this._tableName, Object.values(this._columns));
-    if (this._filter) {
-      queryBuilder.filteredBy(this._filter);
-    }
-
-    queryBuilder.joined([this._join1, this._join2, this._join3, this._join4]);
-
-    let query = '';
-    try {
-      query = queryBuilder.build();
-    } catch (e) {
-      throw new BuilderError(BuilderType.TWO_JOINED_SELECT,
-        this._tableName, Object.values(this._columns), e, this._filter);
-    }
-
-    const parent:
-    { [name in keyof ExtractModel<T1>]: Column<ColumnType>; } = this._join1.mappedServiceToDb;
-    const parentTwo:
-    { [name in keyof ExtractModel<T2>]: Column<ColumnType>; } = this._join2.mappedServiceToDb;
-    const parentThree:
-    { [name in keyof ExtractModel<T3>]: Column<ColumnType>; } = this._join3.mappedServiceToDb;
-    const parentFour:
-    { [name in keyof ExtractModel<T4>]: Column<ColumnType>; } = this._join4.mappedServiceToDb;
-
-    const result = await this._session.execute(query);
-    if (result.isLeft()) {
-      const { reason } = result.value;
-      throw new DatabaseSelectError(this._tableName, reason, query);
-    } else {
-      const response = QueryResponseMapper.map(this._columns, result.value);
-      const objects = QueryResponseMapper.map(parent, result.value);
-      const objectsTwo = QueryResponseMapper.map(parentTwo, result.value);
-      const objectsThree = QueryResponseMapper.map(parentThree, result.value);
-      const objectsFour = QueryResponseMapper.map(parentFour, result.value);
-
-      return new SelectResponseFourJoins(response, objects, objectsTwo, objectsThree, objectsFour);
-    }
-  };
-}

package/src/builders/joinBuilders/builders/selectWithJoin.ts

@@ -1,67 +0,0 @@
-import { Column } from '../../../columns/column';
-import ColumnType from '../../../columns/types/columnType';
-import Session from '../../../db/session';
-import BuilderError, { BuilderType } from '../../../errors/builderError';
-import { DatabaseSelectError } from '../../../errors/dbErrors';
-import QueryResponseMapper from '../../../mappers/responseMapper';
-import { ExtractModel } from '../../../tables/inferTypes';
-import Select from '../../lowLvlBuilders/selects/select';
-import Expr from '../../requestBuilders/where/where';
-import Join from '../join';
-import SelectResponseJoin from '../responses/selectResponseWithJoin';
-import AbstractJoined from './abstractJoinBuilder';
-import SelectTRBWithTwoJoins from './selectWithTwoJoins';
-
-export default class SelectTRBWithJoin<COLUMN extends ColumnType, T1, MODEL>
-  extends AbstractJoined<MODEL> {
-  private _join: Join<COLUMN, T1>;
-
-  public constructor(tableName: string, session: Session,
-    filter: Expr,
-    join: Join<COLUMN, T1>,
-    columns: { [name in keyof ExtractModel<MODEL>]: Column<ColumnType>; }) {
-    super(filter, tableName, session, columns);
-    this._join = join;
-  }
-
-  public join = <T2>(join: Join<COLUMN, T2>):
-  SelectTRBWithTwoJoins<COLUMN, T1, T2, MODEL> => new SelectTRBWithTwoJoins(
-    this._tableName,
-    this._session,
-    this._filter,
-    this._join,
-    join,
-    this._columns,
-  );
-
-  public execute = async (): Promise<SelectResponseJoin<MODEL, T1>> => {
-    const queryBuilder = Select.from(this._tableName, Object.values(this._columns));
-    if (this._filter) {
-      queryBuilder.filteredBy(this._filter);
-    }
-
-    queryBuilder.joined([this._join]);
-
-    let query = '';
-    try {
-      query = queryBuilder.build();
-    } catch (e) {
-      throw new BuilderError(BuilderType.JOINED_SELECT,
-        this._tableName, Object.values(this._columns), e, this._filter);
-    }
-
-    const parent:
-    { [name in keyof ExtractModel<T1>]: Column<ColumnType>; } = this._join.mappedServiceToDb;
-
-    const result = await this._session.execute(query);
-    if (result.isLeft()) {
-      const { reason } = result.value;
-      throw new DatabaseSelectError(this._tableName, reason, query);
-    } else {
-      const response = QueryResponseMapper.map(this._columns, result.value);
-      const objects = QueryResponseMapper.map(parent, result.value);
-
-      return new SelectResponseJoin(response, objects);
-    }
-  };
-}

package/src/builders/joinBuilders/builders/selectWithThreeJoins.ts

@@ -1,78 +0,0 @@
-import { Column } from '../../../columns/column';
-import ColumnType from '../../../columns/types/columnType';
-import Session from '../../../db/session';
-import BuilderError, { BuilderType } from '../../../errors/builderError';
-import { DatabaseSelectError } from '../../../errors/dbErrors';
-import QueryResponseMapper from '../../../mappers/responseMapper';
-import { ExtractModel } from '../../../tables/inferTypes';
-import Select from '../../lowLvlBuilders/selects/select';
-import Expr from '../../requestBuilders/where/where';
-import Join from '../join';
-import SelectResponseThreeJoins from '../responses/selectResponseThreeJoins';
-import AbstractJoined from './abstractJoinBuilder';
-import SelectTRBWithFourJoins from './selectWithFourJoins';
-
-export default class SelectTRBWithThreeJoins<COLUMN extends
-ColumnType, T1, T2, T3, MODEL> extends AbstractJoined<MODEL> {
-  private _join1: Join<COLUMN, T1>;
-  private _join2: Join<COLUMN, T2>;
-  private _join3: Join<COLUMN, T3>;
-
-  public constructor(tableName: string, session: Session,
-    filter: Expr, join1: Join<COLUMN, T1>, join2: Join<COLUMN, T2>, join3: Join<COLUMN, T3>,
-    columns: { [name in keyof ExtractModel<MODEL>]: Column<ColumnType>; }) {
-    super(filter, tableName, session, columns);
-    this._join1 = join1;
-    this._join2 = join2;
-    this._join3 = join3;
-  }
-
-  public join = <T4>(join: Join<COLUMN, T4>):
-  SelectTRBWithFourJoins<COLUMN, T1, T2, T3, T4, MODEL> => new SelectTRBWithFourJoins(
-    this._tableName,
-    this._session,
-    this._filter,
-    this._join1,
-    this._join2,
-    this._join3,
-    join,
-    this._columns,
-  );
-
-  public execute = async (): Promise<SelectResponseThreeJoins<MODEL, T1, T2, T3>> => {
-    const queryBuilder = Select.from(this._tableName, Object.values(this._columns));
-    if (this._filter) {
-      queryBuilder.filteredBy(this._filter);
-    }
-
-    queryBuilder.joined([this._join1, this._join2, this._join3]);
-
-    let query = '';
-    try {
-      query = queryBuilder.build();
-    } catch (e) {
-      throw new BuilderError(BuilderType.TWO_JOINED_SELECT,
-        this._tableName, Object.values(this._columns), e, this._filter);
-    }
-
-    const parent:
-    { [name in keyof ExtractModel<T1>]: Column<ColumnType>; } = this._join1.mappedServiceToDb;
-    const parentTwo:
-    { [name in keyof ExtractModel<T2>]: Column<ColumnType>; } = this._join2.mappedServiceToDb;
-    const parentThree:
-    { [name in keyof ExtractModel<T3>]: Column<ColumnType>; } = this._join3.mappedServiceToDb;
-
-    const result = await this._session.execute(query);
-    if (result.isLeft()) {
-      const { reason } = result.value;
-      throw new DatabaseSelectError(this._tableName, reason, query);
-    } else {
-      const response = QueryResponseMapper.map(this._columns, result.value);
-      const objects = QueryResponseMapper.map(parent, result.value);
-      const objectsTwo = QueryResponseMapper.map(parentTwo, result.value);
-      const objectsThree = QueryResponseMapper.map(parentThree, result.value);
-
-      return new SelectResponseThreeJoins(response, objects, objectsTwo, objectsThree);
-    }
-  };
-}

package/src/builders/joinBuilders/builders/selectWithTwoJoins.ts

@@ -1,72 +0,0 @@
-import { Column } from '../../../columns/column';
-import ColumnType from '../../../columns/types/columnType';
-import Session from '../../../db/session';
-import BuilderError, { BuilderType } from '../../../errors/builderError';
-import { DatabaseSelectError } from '../../../errors/dbErrors';
-import QueryResponseMapper from '../../../mappers/responseMapper';
-import { ExtractModel } from '../../../tables/inferTypes';
-import Select from '../../lowLvlBuilders/selects/select';
-import Expr from '../../requestBuilders/where/where';
-import Join from '../join';
-import SelectResponseTwoJoins from '../responses/selectResponseTwoJoins';
-import AbstractJoined from './abstractJoinBuilder';
-import SelectTRBWithThreeJoins from './selectWithThreeJoins';
-
-export default class SelectTRBWithTwoJoins<COLUMN extends
-ColumnType, T1, T2, MODEL> extends AbstractJoined<MODEL> {
-  private _join1: Join<COLUMN, T1>;
-  private _join2: Join<COLUMN, T2>;
-
-  public constructor(tableName: string, session: Session,
-    filter: Expr, join1: Join<COLUMN, T1>, join2: Join<COLUMN, T2>,
-    columns: { [name in keyof ExtractModel<MODEL>]: Column<ColumnType>; }) {
-    super(filter, tableName, session, columns);
-    this._join1 = join1;
-    this._join2 = join2;
-  }
-
-  public join = <T3>(join: Join<COLUMN, T3>):
-  SelectTRBWithThreeJoins<COLUMN, T1, T2, T3, MODEL> => new SelectTRBWithThreeJoins(
-    this._tableName,
-    this._session,
-    this._filter,
-    this._join1,
-    this._join2,
-    join,
-    this._columns,
-  );
-
-  public execute = async (): Promise<SelectResponseTwoJoins<MODEL, T1, T2>> => {
-    const queryBuilder = Select.from(this._tableName, Object.values(this._columns));
-    if (this._filter) {
-      queryBuilder.filteredBy(this._filter);
-    }
-
-    queryBuilder.joined([this._join1, this._join2]);
-
-    let query = '';
-    try {
-      query = queryBuilder.build();
-    } catch (e) {
-      throw new BuilderError(BuilderType.TWO_JOINED_SELECT,
-        this._tableName, Object.values(this._columns), e, this._filter);
-    }
-
-    const parent:
-    { [name in keyof ExtractModel<T1>]: Column<ColumnType>; } = this._join1.mappedServiceToDb;
-    const parentTwo:
-    { [name in keyof ExtractModel<T2>]: Column<ColumnType>; } = this._join2.mappedServiceToDb;
-
-    const result = await this._session.execute(query);
-    if (result.isLeft()) {
-      const { reason } = result.value;
-      throw new DatabaseSelectError(this._tableName, reason, query);
-    } else {
-      const response = QueryResponseMapper.map(this._columns, result.value);
-      const objects = QueryResponseMapper.map(parent, result.value);
-      const objectsTwo = QueryResponseMapper.map(parentTwo, result.value);
-
-      return new SelectResponseTwoJoins(response, objects, objectsTwo);
-    }
-  };
-}

package/src/builders/joinBuilders/join.ts

@@ -1,37 +0,0 @@
-import { Column } from '../../columns/column';
-import ColumnType from '../../columns/types/columnType';
-import { ExtractModel } from '../../tables/inferTypes';
-
-export default class Join<T extends ColumnType, K> {
-  public fromColumn: Column<T, boolean, boolean>;
-  public toColumn: Column<T, boolean, boolean>;
-  public joinTableName: string;
-  public mappedServiceToDb: { [name in keyof ExtractModel<K>]: Column<ColumnType>; };
-  public type: JoinStrategy;
-
-  public constructor(joinTableName: string, fromColumn: Column<T, boolean, boolean>,
-    toColumn: Column<T, boolean, boolean>,
-    mappedServiceToDb: { [name in keyof ExtractModel<K>]: Column<ColumnType>; }) {
-    this.joinTableName = joinTableName;
-    this.toColumn = toColumn;
-    this.fromColumn = fromColumn;
-    this.mappedServiceToDb = mappedServiceToDb;
-  }
-
-  public joinStrategy = (type: JoinStrategy): Join<T, K> => {
-    this.type = type;
-    return this;
-  };
-
-  public columns = (fromColumn:Column<T>, toColumn:Column<T>): Join<T, K> => {
-    this.toColumn = toColumn;
-    this.fromColumn = fromColumn;
-    return this;
-  };
-}
-
-export enum JoinStrategy {
-  INNER_JOIN = 'INNER JOIN',
-  LEFT_JOIN = 'LEFT JOIN',
-  RIGHT_JOIN = 'RIGHT JOIN',
-}

package/src/builders/joinBuilders/joinWith.ts

@@ -1,19 +0,0 @@
-import { Column } from '../../columns/column';
-import ColumnType from '../../columns/types/columnType';
-import { ExtractModel } from '../../tables/inferTypes';
-import Join from './join';
-
-export default class JoinWith<T extends ColumnType, K> {
-  public joinTableName: string;
-  public mappedServiceToDb: { [name in keyof ExtractModel<K>]: Column<ColumnType>; };
-
-  public constructor(joinTableName: string,
-    mappedServiceToDb: { [name in keyof ExtractModel<K>]: Column<ColumnType>; }) {
-    this.joinTableName = joinTableName;
-    this.mappedServiceToDb = mappedServiceToDb;
-  }
-
-  public columns = (fromColumn:Column<T, boolean, boolean>,
-    toColumn:Column<T, boolean, boolean>): Join<T, K> => new Join(this.joinTableName,
-    fromColumn, toColumn, this.mappedServiceToDb);
-}

package/src/builders/joinBuilders/responses/selectResponseFourJoins.ts

@@ -1,33 +0,0 @@
-import { ExtractModel } from '../../../tables/inferTypes';
-
-export default class SelectResponseFourJoins<T1, T2, T3, T4, T5> {
-  private _t1: ExtractModel<T1>[];
-  private _t2: ExtractModel<T2>[];
-  private _t3: ExtractModel<T3>[];
-  private _t4: ExtractModel<T4>[];
-  private _t5: ExtractModel<T5>[];
-
-  public constructor(t1: ExtractModel<T1>[],
-    t2: ExtractModel<T2>[],
-    t3: ExtractModel<T3>[],
-    t4: ExtractModel<T4>[],
-    t5: ExtractModel<T5>[]) {
-    this._t1 = t1;
-    this._t2 = t2;
-    this._t3 = t3;
-    this._t4 = t4;
-    this._t5 = t5;
-  }
-
-  public mapByRow = <M>(imac: (t1: ExtractModel<T1>,
-    t2:ExtractModel<T2>,
-    t3: ExtractModel<T3>,
-    t4: ExtractModel<T4>,
-    t5: ExtractModel<T5>) => M): Array<M> => {
-    const objects = new Array<M>();
-    for (let i = 0; i < this._t1.length; i += 1) {
-      objects.push(imac(this._t1[i], this._t2[i], this._t3[i], this._t4[i], this._t5[i]));
-    }
-    return objects;
-  };
-}

package/src/builders/joinBuilders/responses/selectResponseThreeJoins.ts

@@ -1,29 +0,0 @@
-import { ExtractModel } from '../../../tables/inferTypes';
-
-export default class SelectResponseThreeJoins<T1, T2, T3, T4> {
-  private _t1: ExtractModel<T1>[];
-  private _t2: ExtractModel<T2>[];
-  private _t3: ExtractModel<T3>[];
-  private _t4: ExtractModel<T4>[];
-
-  public constructor(t1: ExtractModel<T1>[],
-    t2: ExtractModel<T2>[],
-    t3: ExtractModel<T3>[],
-    t4: ExtractModel<T4>[]) {
-    this._t1 = t1;
-    this._t2 = t2;
-    this._t3 = t3;
-    this._t4 = t4;
-  }
-
-  public mapByRow = <M>(imac: (t1: ExtractModel<T1>,
-    t2: ExtractModel<T2>,
-    t3: ExtractModel<T3>,
-    t4: ExtractModel<T4>) => M): Array<M> => {
-    const objects = new Array<M>();
-    for (let i = 0; i < this._t1.length; i += 1) {
-      objects.push(imac(this._t1[i], this._t2[i], this._t3[i], this._t4[i]));
-    }
-    return objects;
-  };
-}

package/src/builders/joinBuilders/responses/selectResponseTwoJoins.ts

@@ -1,22 +0,0 @@
-import { ExtractModel } from '../../../tables/inferTypes';
-
-export default class SelectResponseTwoJoins<T1, T2, T3> {
-  private _t1: ExtractModel<T1>[];
-  private _t2: ExtractModel<T2>[];
-  private _t3: ExtractModel<T3>[];
-
-  public constructor(t1: ExtractModel<T1>[], t2: ExtractModel<T2>[], t3: ExtractModel<T3>[]) {
-    this._t1 = t1;
-    this._t2 = t2;
-    this._t3 = t3;
-  }
-
-  public mapByRow = <M>(imac: (t1: ExtractModel<T1>, t2:
-  ExtractModel<T2>, t3: ExtractModel<T3>) => M): Array<M> => {
-    const objects = new Array<M>();
-    for (let i = 0; i < this._t1.length; i += 1) {
-      objects.push(imac(this._t1[i], this._t2[i], this._t3[i]));
-    }
-    return objects;
-  };
-}

package/src/builders/joinBuilders/responses/selectResponseWithJoin.ts

@@ -1,28 +0,0 @@
-import { ExtractModel } from '../../../tables/inferTypes';
-
-export default class SelectResponseJoin<MODEL, T2> {
-  private _t1: ExtractModel<MODEL>[];
-  private _t2: ExtractModel<T2>[];
-
-  public constructor(t1: ExtractModel<MODEL>[], t2: ExtractModel<T2>[]) {
-    this._t1 = t1;
-    this._t2 = t2;
-  }
-
-  public mapByRow = <M>(imac: (t1: ExtractModel<MODEL>, t2: ExtractModel<T2>) => M): Array<M> => {
-    const objects = new Array<M>();
-    for (let i = 0; i < this._t1.length; i += 1) {
-      objects.push(imac(this._t1[i], this._t2[i]));
-    }
-    return objects;
-  };
-
-  public mapByResult = <M>(imac: (t1: ExtractModel<MODEL>, t2: ExtractModel<T2>) => M)
-  : Array<M> => {
-    const objects = new Array<M>();
-    for (let i = 0; i < this._t1.length; i += 1) {
-      objects.push(imac(this._t1[i], this._t2[i]));
-    }
-    return objects;
-  };
-}

package/src/builders/joinBuilders/static.ts

@@ -1,9 +0,0 @@
-import ColumnType from '../../columns/types/columnType';
-import AbstractTable from '../../tables/abstractTable';
-import JoinWith from './joinWith';
-
-const to = <COLUMN extends ColumnType, MODEL>(table: AbstractTable<MODEL>):
-JoinWith<COLUMN, MODEL> => new JoinWith(table.tableName(), table.mapServiceToDb());
-
-// eslint-disable-next-line import/prefer-default-export
-export default to;