drizzle-orm 0.10.25 → 0.10.28

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

@@ -0,0 +1,210 @@
+/* eslint-disable max-len */
+/* eslint-disable import/no-cycle */
+import { QueryResult } from 'pg';
+import { AbstractColumn } from '../../../columns/column';
+import ColumnType from '../../../columns/types/columnType';
+import DB from '../../../db/db';
+import { ISession } from '../../../db/session';
+import AbstractTable from '../../../tables/abstractTable';
+import { CheckThreeTypes, ExtractModel, PartialFor } from '../../../tables/inferTypes';
+import Order from '../../highLvlBuilders/order';
+import Expr from '../../requestBuilders/where/where';
+import Join, { JoinStrategy } from '../join';
+import JoinWith from '../joinWith';
+import SelectResponseTwoJoins from '../responses/selectResponseTwoJoins';
+import AbstractJoined from './abstractJoinBuilder';
+import SelectTRBWithThreeJoins from './selectWithThreeJoins';
+
+export default class SelectTRBWithTwoJoins<TTable extends AbstractTable<TTable>, TTable1 extends AbstractTable<TTable1>, TTable2 extends AbstractTable<TTable2>,
+  TPartial extends PartialFor<TTable> = {},
+  TPartial1 extends PartialFor<TTable1> = {},
+  TPartial2 extends PartialFor<TTable2> = {}>
+  extends AbstractJoined<TTable, SelectResponseTwoJoins<TTable, TTable1, TTable2, TPartial, TPartial1, TPartial2>, TPartial> {
+  private _join1: Join<TTable1>;
+  private _join2: Join<TTable2>;
+
+  private _joinedPartial?: TPartial1;
+  private _joinedPartial1?: TPartial2;
+
+  public 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>,
+    tablePartial?: TPartial,
+    joinedPartial?: TPartial1,
+    joinedPartial1?: TPartial2,
+  ) {
+    super(table, filter, session, props, orderBy, order, distinct, tablePartial);
+    this._join1 = join1;
+    this._join2 = join2;
+
+    this._joinedPartial = joinedPartial;
+    this._joinedPartial1 = joinedPartial1;
+  }
+
+  public innerJoin<InputTable extends AbstractTable<InputTable>, TColumn extends ColumnType, TToColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(
+    fromTable: { new(db: DB): InputTable ;},
+    table: { new(db: DB): IToTable ;},
+    from: (table: CheckThreeTypes<InputTable, TTable, TTable1, TTable2>) => AbstractColumn<TColumn, boolean, boolean, CheckThreeTypes<InputTable, TTable, TTable1, TTable2>>,
+    to: (table: IToTable) => AbstractColumn<TToColumn, boolean, boolean, IToTable>,
+    partial?: IToPartial,
+  ): SelectTRBWithThreeJoins<TTable, TTable1, TTable2, IToTable, TPartial, TPartial1, TPartial2, IToPartial> {
+    const toTable = this._table.db.create(table);
+    const tableFrom = this._table.db.create(fromTable);
+
+    const fromColumn = from(tableFrom as unknown as CheckThreeTypes<InputTable, TTable, TTable1, TTable2>);
+    const toColumn = to(toTable);
+
+    const join = new JoinWith(toTable.tableName(), toTable.mapServiceToDb())
+      .columns(fromColumn, toColumn).joinStrategy(JoinStrategy.INNER_JOIN);
+
+    return new SelectTRBWithThreeJoins(
+      this._table,
+      this._session,
+      this._filter,
+      this._join1,
+      this._join2,
+      join,
+      this._props,
+      this._orderBy,
+      this._order,
+      this._distinct,
+      this._partial,
+      this._joinedPartial,
+      this._joinedPartial1,
+      partial,
+    );
+  }
+
+  public leftJoin<InputTable extends AbstractTable<InputTable>, TColumn extends ColumnType, TToColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(
+    fromTable: { new(db: DB): InputTable ;},
+    table: { new(db: DB): IToTable ;},
+    from: (table: CheckThreeTypes<InputTable, TTable, TTable1, TTable2>) => AbstractColumn<TColumn, boolean, boolean, CheckThreeTypes<InputTable, TTable, TTable1, TTable2>>,
+    to: (table: IToTable) => AbstractColumn<TToColumn, boolean, boolean, IToTable>,
+    partial?: IToPartial,
+  ): SelectTRBWithThreeJoins<TTable, TTable1, TTable2, IToTable, TPartial, TPartial1, TPartial2, IToPartial> {
+    const toTable = this._table.db.create(table);
+    const tableFrom = this._table.db.create(fromTable);
+
+    const fromColumn = from(tableFrom as unknown as CheckThreeTypes<InputTable, TTable, TTable1, TTable2>);
+    const toColumn = to(toTable);
+
+    const join = new JoinWith(toTable.tableName(), toTable.mapServiceToDb())
+      .columns(fromColumn, toColumn).joinStrategy(JoinStrategy.LEFT_JOIN);
+
+    return new SelectTRBWithThreeJoins(
+      this._table,
+      this._session,
+      this._filter,
+      this._join1,
+      this._join2,
+      join,
+      this._props,
+      this._orderBy,
+      this._order,
+      this._distinct,
+      this._partial,
+      this._joinedPartial,
+      this._joinedPartial1,
+      partial,
+    );
+  }
+
+  public rightJoin<InputTable extends AbstractTable<InputTable>, TColumn extends ColumnType, TToColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(
+    fromTable: { new(db: DB): InputTable ;},
+    table: { new(db: DB): IToTable ;},
+    from: (table: CheckThreeTypes<InputTable, TTable, TTable1, TTable2>) => AbstractColumn<TColumn, boolean, boolean, CheckThreeTypes<InputTable, TTable, TTable1, TTable2>>,
+    to: (table: IToTable) => AbstractColumn<TToColumn, boolean, boolean, IToTable>,
+    partial?: IToPartial,
+  ): SelectTRBWithThreeJoins<TTable, TTable1, TTable2, IToTable, TPartial, TPartial1, TPartial2, IToPartial> {
+    const toTable = this._table.db.create(table);
+    const tableFrom = this._table.db.create(fromTable);
+
+    const fromColumn = from(tableFrom as unknown as CheckThreeTypes<InputTable, TTable, TTable1, TTable2>);
+    const toColumn = to(toTable);
+
+    const join = new JoinWith(toTable.tableName(), toTable.mapServiceToDb())
+      .columns(fromColumn, toColumn).joinStrategy(JoinStrategy.RIGHT_JOIN);
+
+    return new SelectTRBWithThreeJoins(
+      this._table,
+      this._session,
+      this._filter,
+      this._join1,
+      this._join2,
+      join,
+      this._props,
+      this._orderBy,
+      this._order,
+      this._distinct,
+      this._partial,
+      this._joinedPartial,
+      this._joinedPartial1,
+      partial,
+    );
+  }
+
+  public fullJoin<InputTable extends AbstractTable<InputTable>, TColumn extends ColumnType, TToColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(
+    fromTable: { new(db: DB): InputTable ;},
+    table: { new(db: DB): IToTable ;},
+    from: (table: CheckThreeTypes<InputTable, TTable, TTable1, TTable2>) => AbstractColumn<TColumn, boolean, boolean, CheckThreeTypes<InputTable, TTable, TTable1, TTable2>>,
+    to: (table: IToTable) => AbstractColumn<TToColumn, boolean, boolean, IToTable>,
+    partial?: IToPartial,
+  ): SelectTRBWithThreeJoins<TTable, TTable1, TTable2, IToTable, TPartial, TPartial1, TPartial2, IToPartial> {
+    const toTable = this._table.db.create(table);
+    const tableFrom = this._table.db.create(fromTable);
+
+    const fromColumn = from(tableFrom as unknown as CheckThreeTypes<InputTable, TTable, TTable1, TTable2>);
+    const toColumn = to(toTable);
+
+    const join = new JoinWith(toTable.tableName(), toTable.mapServiceToDb())
+      .columns(fromColumn, toColumn).joinStrategy(JoinStrategy.FULL_JOIN);
+
+    return new SelectTRBWithThreeJoins(
+      this._table,
+      this._session,
+      this._filter,
+      this._join1,
+      this._join2,
+      join,
+      this._props,
+      this._orderBy,
+      this._order,
+      this._distinct,
+      this._partial,
+      this._joinedPartial,
+      this._joinedPartial1,
+      partial,
+    );
+  }
+
+  protected mapResponse(result: QueryResult<any>)
+    : SelectResponseTwoJoins<TTable, TTable1, TTable2, TPartial, TPartial1, TPartial2> {
+    const parent:
+    { [name in keyof ExtractModel<TTable1>]:
+      AbstractColumn<ColumnType>; } = this._join1.mappedServiceToDb;
+    const parentTwo:
+    { [name in keyof ExtractModel<TTable2>]:
+      AbstractColumn<ColumnType>; } = this._join2.mappedServiceToDb;
+
+    const response = this.fullOrPartial(this._table.mapServiceToDb(), result, this._partial);
+    const objects = this.fullOrPartial(parent, result, this._joinedPartial, 1);
+    const objectsTwo = this.fullOrPartial(parentTwo, result, this._joinedPartial1, 2);
+
+    return new SelectResponseTwoJoins(response, objects, objectsTwo);
+  }
+
+  protected joins(): Array<{
+    join: Join<any>, partial?: {[name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, any>},
+    id?: number
+  }> {
+    return [{ join: this._join1, partial: this._joinedPartial, id: 1 },
+      { join: this._join2, partial: this._joinedPartial1, id: 2 }];
+  }
+}

package/src/builders/joinBuilders/join.ts

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

package/src/builders/joinBuilders/joinWith.ts

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

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

@@ -0,0 +1,82 @@
+/* eslint-disable max-len */
+import AbstractTable from '../../../tables/abstractTable';
+import { FullOrPartial, PartialFor } from '../../../tables/inferTypes';
+
+export default class SelectResponseFiveJoins<T1 extends AbstractTable<T1>, T2 extends AbstractTable<T2>, T3 extends AbstractTable<T3>, T4 extends AbstractTable<T4>, T5 extends AbstractTable<T5>, T6 extends AbstractTable<T6>,
+TPartial1 extends PartialFor<T1>, TPartial2 extends PartialFor<T2>, TPartial3 extends PartialFor<T3>, TPartial4 extends PartialFor<T4>, TPartial5 extends PartialFor<T5>, TPartial6 extends PartialFor<T6>> {
+  public _t1: Array<FullOrPartial<T1, TPartial1>>;
+  public _t2: Array<FullOrPartial<T2, TPartial2>>;
+  public _t3: Array<FullOrPartial<T3, TPartial3>>;
+  public _t4: Array<FullOrPartial<T4, TPartial4>>;
+  public _t5: Array<FullOrPartial<T5, TPartial5>>;
+  public _t6: Array<FullOrPartial<T6, TPartial6>>;
+
+  public constructor(
+    t1: Array<FullOrPartial<T1, TPartial1>>,
+    t2: Array<FullOrPartial<T2, TPartial2>>,
+    t3: Array<FullOrPartial<T3, TPartial3>>,
+    t4: Array<FullOrPartial<T4, TPartial4>>,
+    t5: Array<FullOrPartial<T5, TPartial5>>,
+    t6: Array<FullOrPartial<T6, TPartial6>>,
+  ) {
+    this._t1 = t1;
+    this._t2 = t2;
+    this._t3 = t3;
+    this._t4 = t4;
+    this._t5 = t5;
+    this._t6 = t6;
+  }
+
+  public map = <M>(imac: (t1: FullOrPartial<T1, TPartial1>,
+    t2: FullOrPartial<T2, TPartial2>,
+    t3: FullOrPartial<T3, TPartial3>,
+    t4: FullOrPartial<T4, TPartial4>,
+    t5: FullOrPartial<T5, TPartial5>,
+    t6: FullOrPartial<T6, TPartial6>) => 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], this._t6[i]));
+    }
+    return objects;
+  };
+
+  public foreach = (imac: (t1: FullOrPartial<T1, TPartial1>,
+    t2: FullOrPartial<T2, TPartial2>,
+    t3: FullOrPartial<T3, TPartial3>,
+    t4: FullOrPartial<T4, TPartial4>,
+    t5: FullOrPartial<T5, TPartial5>,
+    t6: FullOrPartial<T6, TPartial6>) => void): void => {
+    for (let i = 0; i < this._t1.length; i += 1) {
+      imac(this._t1[i], this._t2[i], this._t3[i], this._t4[i], this._t5[i], this._t6[i]);
+    }
+  };
+
+  public group = <TOne, TMany>({
+    one,
+    many,
+  }:{
+    one: (t1: FullOrPartial<T1, TPartial1>,
+      t2: FullOrPartial<T2, TPartial2>,
+      t3: FullOrPartial<T3, TPartial3>,
+      t4: FullOrPartial<T4, TPartial4>,
+      t5: FullOrPartial<T5, TPartial5>,
+      t6: FullOrPartial<T6, TPartial6>) => TOne,
+    many: (t1: FullOrPartial<T1, TPartial1>,
+      t2: FullOrPartial<T2, TPartial2>,
+      t3: FullOrPartial<T3, TPartial3>,
+      t4: FullOrPartial<T4, TPartial4>,
+      t5: FullOrPartial<T5, TPartial5>,
+      t6: FullOrPartial<T6, TPartial6>) => TMany
+  }) => {
+    const objects = new Array<TMany>();
+    for (let i = 0; i < this._t1.length; i += 1) {
+      objects.push(many(this._t1[i], this._t2[i], this._t3[i],
+        this._t4[i], this._t5[i], this._t6[i]));
+    }
+    return {
+      one: one(this._t1[0], this._t2[0], this._t3[0], this._t4[0], this._t5[0], this._t6[0]),
+      many: objects,
+    };
+  };
+}

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

@@ -0,0 +1,73 @@
+/* eslint-disable max-len */
+import AbstractTable from '../../../tables/abstractTable';
+import { FullOrPartial, PartialFor } from '../../../tables/inferTypes';
+
+export default class SelectResponseFourJoins<T1 extends AbstractTable<T1>, T2 extends AbstractTable<T2>, T3 extends AbstractTable<T3>, T4 extends AbstractTable<T4>, T5 extends AbstractTable<T5>,
+TPartial1 extends PartialFor<T1>, TPartial2 extends PartialFor<T2>, TPartial3 extends PartialFor<T3>, TPartial4 extends PartialFor<T4>, TPartial5 extends PartialFor<T5>> {
+  public _t1: Array<FullOrPartial<T1, TPartial1>>;
+  public _t2: Array<FullOrPartial<T2, TPartial2>>;
+  public _t3: Array<FullOrPartial<T3, TPartial3>>;
+  public _t4: Array<FullOrPartial<T4, TPartial4>>;
+  public _t5: Array<FullOrPartial<T5, TPartial5>>;
+
+  public constructor(
+    t1: Array<FullOrPartial<T1, TPartial1>>,
+    t2: Array<FullOrPartial<T2, TPartial2>>,
+    t3: Array<FullOrPartial<T3, TPartial3>>,
+    t4: Array<FullOrPartial<T4, TPartial4>>,
+    t5: Array<FullOrPartial<T5, TPartial5>>,
+  ) {
+    this._t1 = t1;
+    this._t2 = t2;
+    this._t3 = t3;
+    this._t4 = t4;
+    this._t5 = t5;
+  }
+
+  public map = <M>(imac: (t1: FullOrPartial<T1, TPartial1>,
+    t2: FullOrPartial<T2, TPartial2>,
+    t3: FullOrPartial<T3, TPartial3>,
+    t4: FullOrPartial<T4, TPartial4>,
+    t5: FullOrPartial<T5, TPartial5>) => 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;
+  };
+
+  public foreach = (imac: (t1: FullOrPartial<T1, TPartial1>,
+    t2: FullOrPartial<T2, TPartial2>,
+    t3: FullOrPartial<T3, TPartial3>,
+    t4: FullOrPartial<T4, TPartial4>,
+    t5: FullOrPartial<T5, TPartial5>) => void): void => {
+    for (let i = 0; i < this._t1.length; i += 1) {
+      imac(this._t1[i], this._t2[i], this._t3[i], this._t4[i], this._t5[i]);
+    }
+  };
+
+  public group = <TOne, TMany>({
+    one,
+    many,
+  }:{
+    one: (t1: FullOrPartial<T1, TPartial1>,
+      t2: FullOrPartial<T2, TPartial2>,
+      t3: FullOrPartial<T3, TPartial3>,
+      t4: FullOrPartial<T4, TPartial4>,
+      t5: FullOrPartial<T5, TPartial5>) => TOne,
+    many: (t1: FullOrPartial<T1, TPartial1>,
+      t2: FullOrPartial<T2, TPartial2>,
+      t3: FullOrPartial<T3, TPartial3>,
+      t4: FullOrPartial<T4, TPartial4>,
+      t5: FullOrPartial<T5, TPartial5>) => TMany
+  }) => {
+    const objects = new Array<TMany>();
+    for (let i = 0; i < this._t1.length; i += 1) {
+      objects.push(many(this._t1[i], this._t2[i], this._t3[i], this._t4[i], this._t5[i]));
+    }
+    return {
+      one: one(this._t1[0], this._t2[0], this._t3[0], this._t4[0], this._t5[0]),
+      many: objects,
+    };
+  };
+}

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

@@ -0,0 +1,64 @@
+/* eslint-disable max-len */
+import AbstractTable from '../../../tables/abstractTable';
+import { FullOrPartial, PartialFor } from '../../../tables/inferTypes';
+
+export default class SelectResponseThreeJoins<T1 extends AbstractTable<T1>, T2 extends AbstractTable<T2>, T3 extends AbstractTable<T3>, T4 extends AbstractTable<T4>,
+TPartial1 extends PartialFor<T1>, TPartial2 extends PartialFor<T2>, TPartial3 extends PartialFor<T3>, TPartial4 extends PartialFor<T4>> {
+  private _t1: Array<FullOrPartial<T1, TPartial1>>;
+  private _t2: Array<FullOrPartial<T2, TPartial2>>;
+  private _t3: Array<FullOrPartial<T3, TPartial3>>;
+  private _t4: Array<FullOrPartial<T4, TPartial4>>;
+
+  public constructor(t1: Array<FullOrPartial<T1, TPartial1>>,
+    t2: Array<FullOrPartial<T2, TPartial2>>,
+    t3: Array<FullOrPartial<T3, TPartial3>>,
+    t4: Array<FullOrPartial<T4, TPartial4>>) {
+    this._t1 = t1;
+    this._t2 = t2;
+    this._t3 = t3;
+    this._t4 = t4;
+  }
+
+  public map = <M>(imac: (t1: FullOrPartial<T1, TPartial1>,
+    t2: FullOrPartial<T2, TPartial2>,
+    t3: FullOrPartial<T3, TPartial3>,
+    t4: FullOrPartial<T4, TPartial4>) => 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;
+  };
+
+  public foreach = (imac: (t1: FullOrPartial<T1, TPartial1>,
+    t2: FullOrPartial<T2, TPartial2>,
+    t3: FullOrPartial<T3, TPartial3>,
+    t4: FullOrPartial<T4, TPartial4>) => void): void => {
+    for (let i = 0; i < this._t1.length; i += 1) {
+      imac(this._t1[i], this._t2[i], this._t3[i], this._t4[i]);
+    }
+  };
+
+  public group = <TOne, TMany>({
+    one,
+    many,
+  }:{
+    one: (t1: FullOrPartial<T1, TPartial1>,
+      t2: FullOrPartial<T2, TPartial2>,
+      t3: FullOrPartial<T3, TPartial3>,
+      t4: FullOrPartial<T4, TPartial4>) => TOne,
+    many: (t1: FullOrPartial<T1, TPartial1>,
+      t2: FullOrPartial<T2, TPartial2>,
+      t3: FullOrPartial<T3, TPartial3>,
+      t4: FullOrPartial<T4, TPartial4>) => TMany
+  }) => {
+    const objects = new Array<TMany>();
+    for (let i = 0; i < this._t1.length; i += 1) {
+      objects.push(many(this._t1[i], this._t2[i], this._t3[i], this._t4[i]));
+    }
+    return {
+      one: one(this._t1[0], this._t2[0], this._t3[0], this._t4[0]),
+      many: objects,
+    };
+  };
+}

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

@@ -0,0 +1,57 @@
+/* eslint-disable max-len */
+import AbstractTable from '../../../tables/abstractTable';
+import { FullOrPartial, PartialFor } from '../../../tables/inferTypes';
+
+export default class SelectResponseTwoJoins<T1 extends AbstractTable<T1>, T2 extends AbstractTable<T2>, T3 extends AbstractTable<T3>,
+  TPartial1 extends PartialFor<T1>, TPartial2 extends PartialFor<T2>, TPartial3 extends PartialFor<T3>> {
+  private _t1: Array<FullOrPartial<T1, TPartial1>>;
+  private _t2: Array<FullOrPartial<T2, TPartial2>>;
+  private _t3: Array<FullOrPartial<T3, TPartial3>>;
+
+  public constructor(t1: Array<FullOrPartial<T1, TPartial1>>,
+    t2: Array<FullOrPartial<T2, TPartial2>>,
+    t3: Array<FullOrPartial<T3, TPartial3>>) {
+    this._t1 = t1;
+    this._t2 = t2;
+    this._t3 = t3;
+  }
+
+  public map = <M>(imac: (t1: FullOrPartial<T1, TPartial1>,
+    t2: FullOrPartial<T2, TPartial2>,
+    t3: FullOrPartial<T3, TPartial3>) => 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;
+  };
+
+  public foreach = (imac: (t1: FullOrPartial<T1, TPartial1>,
+    t2: FullOrPartial<T2, TPartial2>,
+    t3: FullOrPartial<T3, TPartial3>) => void): void => {
+    for (let i = 0; i < this._t1.length; i += 1) {
+      imac(this._t1[i], this._t2[i], this._t3[i]);
+    }
+  };
+
+  public group = <TOne, TMany>({
+    one,
+    many,
+  }:{
+    one: (t1: FullOrPartial<T1, TPartial1>,
+      t2: FullOrPartial<T2, TPartial2>,
+      t3: FullOrPartial<T3, TPartial3>) => TOne,
+    many: (t1: FullOrPartial<T1, TPartial1>,
+      t2: FullOrPartial<T2, TPartial2>,
+      t3: FullOrPartial<T3, TPartial3>) => TMany
+  }) => {
+    const objects = new Array<TMany>();
+    for (let i = 0; i < this._t1.length; i += 1) {
+      objects.push(many(this._t1[i], this._t2[i], this._t3[i]));
+    }
+    return {
+      one: one(this._t1[0], this._t2[0], this._t3[0]),
+      many: objects,
+    };
+  };
+}

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

@@ -0,0 +1,49 @@
+/* eslint-disable max-len */
+import AbstractTable from '../../../tables/abstractTable';
+import { FullOrPartial, PartialFor } from '../../../tables/inferTypes';
+
+export default class SelectResponseJoin<TTable1 extends AbstractTable<TTable1>, TTable2 extends AbstractTable<TTable2>, TPartial1 extends PartialFor<TTable1>, TPartial2 extends PartialFor<TTable2>> {
+  private _t1: Array<FullOrPartial<TTable1, TPartial1>>;
+  private _t2: Array<FullOrPartial<TTable2, TPartial2>>;
+
+  public constructor(t1: Array<FullOrPartial<TTable1, TPartial1>>,
+    t2: Array<FullOrPartial<TTable2, TPartial2>>) {
+    this._t1 = t1;
+    this._t2 = t2;
+  }
+
+  public map = <M>(imac: (t1: FullOrPartial<TTable1, TPartial1>,
+    t2: FullOrPartial<TTable2, TPartial2>) => 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 foreach = (imac: (t1: FullOrPartial<TTable1, TPartial1>,
+    t2: FullOrPartial<TTable2, TPartial2>) => void): void => {
+    for (let i = 0; i < this._t1.length; i += 1) {
+      imac(this._t1[i], this._t2[i]);
+    }
+  };
+
+  public group = <TOne, TMany>({
+    one,
+    many,
+  }:{
+    one: (t1: FullOrPartial<TTable1, TPartial1>,
+      t2: FullOrPartial<TTable2, TPartial2>) => TOne,
+    many: (t1: FullOrPartial<TTable1, TPartial1>,
+      t2: FullOrPartial<TTable2, TPartial2>) => TMany
+  }) => {
+    const objects = new Array<TMany>();
+    for (let i = 0; i < this._t1.length; i += 1) {
+      objects.push(many(this._t1[i], this._t2[i]));
+    }
+    return {
+      one: one(this._t1[0], this._t2[0]),
+      many: objects,
+    };
+  };
+}

package/src/builders/joinBuilders/static.ts

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