drizzle-orm 0.10.29 → 0.10.32

package/src/builders/highLvlBuilders/selectRequestBuilder.ts

@@ -1,229 +0,0 @@
-/* eslint-disable max-len */
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/member-ordering */
-/* eslint-disable import/no-cycle */
-import { QueryResult } from 'pg';
-import { JoinWith, Select } from '..';
-import { AbstractColumn } from '../../columns/column';
-import ColumnType from '../../columns/types/columnType';
-import DB from '../../db/db';
-import { ISession } from '../../db/session';
-import BuilderError, { BuilderType } from '../../errors/builderError';
-import BaseLogger from '../../logger/abstractLogger';
-import QueryResponseMapper from '../../mappers/responseMapper';
-import { AbstractTable } from '../../tables';
-import { ExtractModel, ExtractPartialObjectFromColumns, PartialFor } from '../../tables/inferTypes';
-import SelectTRBWithJoin from '../joinBuilders/builders/selectWithJoin';
-import { JoinStrategy } from '../joinBuilders/join';
-import Expr from '../requestBuilders/where/where';
-import TableRequestBuilder from './abstractRequestBuilder';
-import Order from './order';
-
-export default class SelectTRB<TTable extends AbstractTable<TTable>, TPartial extends {[name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, TTable>} = {}>
-  extends TableRequestBuilder<TTable, TPartial> {
-  protected _filter: Expr;
-  private props: { limit?: number, offset?: number};
-  private __orderBy?: AbstractColumn<ColumnType, boolean, boolean>;
-  private __groupBy?: AbstractColumn<ColumnType, boolean, boolean>;
-  private __order?: Order;
-  private __distinct: AbstractColumn<ColumnType, boolean, boolean>;
-  private __partial?: TPartial;
-
-  public constructor(
-    session: ISession,
-    mappedServiceToDb: { [name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>; },
-    props: {limit?:number, offset?:number},
-    table: AbstractTable<TTable>,
-    logger?: BaseLogger,
-    partial?: TPartial,
-  ) {
-    super(table, session, mappedServiceToDb, logger);
-    this.props = props;
-    this.__partial = partial;
-  }
-
-  public where = (expr: Expr): SelectTRB<TTable, TPartial> => {
-    this._filter = expr;
-    return this;
-  };
-
-  public orderBy<TColumnType extends ColumnType>(
-    callback: (table: TTable) => AbstractColumn<TColumnType, boolean, boolean>,
-    order: Order,
-  )
-    : SelectTRB<TTable, TPartial> {
-    this.__orderBy = callback(this._table);
-    this.__order = order;
-    return this;
-  }
-
-  public distinct = (column: AbstractColumn<ColumnType<any>, boolean, boolean>)
-  : SelectTRB<TTable, TPartial> => {
-    this.__distinct = column;
-    return this;
-  };
-
-  public limit = (limit: number): SelectTRB<TTable, TPartial> => {
-    this.props.limit = limit;
-    return this;
-  };
-
-  public offset = (offset: number): SelectTRB<TTable, TPartial> => {
-    this.props.offset = offset;
-    return this;
-  };
-
-  // public groupBy(callback: (table: TTable) => Column<ColumnType, boolean, boolean>)
-  //   : SelectTRB<TTable> {
-  //   this.__groupBy = callback(this.__table);
-  //   return this;
-  // }
-
-  public innerJoin<TColumn extends ColumnType, TToColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(
-    table: { new(db: DB): IToTable ;},
-    from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean>,
-    to: (table: IToTable) => AbstractColumn<TToColumn, boolean, boolean>,
-    partial?: IToPartial,
-  ): SelectTRBWithJoin<TTable, IToTable, TPartial, IToPartial> {
-    const toTable = this._table.db.create(table);
-
-    const fromColumn = from(this._table);
-    const toColumn = to(toTable);
-
-    const join = new JoinWith(toTable.tableName(), toTable.mapServiceToDb())
-      .columns(fromColumn, toColumn).joinStrategy(JoinStrategy.INNER_JOIN);
-
-    return new SelectTRBWithJoin(
-      this._table,
-      this._session,
-      this._filter,
-      join,
-      this.props,
-      this.__orderBy,
-      this.__order,
-      this.__distinct,
-      this.__partial,
-      partial,
-    );
-  }
-
-  public leftJoin<TColumn extends ColumnType<any>, IToColumn extends ColumnType<any>, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(
-    table: { new(db: DB): IToTable ;},
-    from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean, TTable>,
-    to: (table: IToTable) => AbstractColumn<IToColumn, boolean, boolean, IToTable>,
-    partial?: IToPartial,
-  ): SelectTRBWithJoin<TTable, IToTable, TPartial, IToPartial> {
-    const toTable = this._table.db.create(table);
-
-    const fromColumn = from(this._table);
-    const toColumn = to(toTable);
-
-    const join = new JoinWith(toTable.tableName(), toTable.mapServiceToDb())
-      .columns(fromColumn, toColumn).joinStrategy(JoinStrategy.LEFT_JOIN);
-
-    return new SelectTRBWithJoin(
-      this._table,
-      this._session,
-      this._filter,
-      join,
-      this.props,
-      this.__orderBy,
-      this.__order,
-      this.__distinct,
-      this.__partial,
-      partial,
-    );
-  }
-
-  public rightJoin<TColumn extends ColumnType, TToColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(
-    table: { new(db: DB): IToTable ;},
-    from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean>,
-    to: (table: IToTable) => AbstractColumn<TToColumn, boolean, boolean>,
-    partial?: IToPartial,
-  ): SelectTRBWithJoin<TTable, IToTable, TPartial, IToPartial> {
-    const toTable = this._table.db.create(table);
-
-    const fromColumn = from(this._table);
-    const toColumn = to(toTable);
-
-    const join = new JoinWith(toTable.tableName(), toTable.mapServiceToDb())
-      .columns(fromColumn, toColumn).joinStrategy(JoinStrategy.RIGHT_JOIN);
-
-    return new SelectTRBWithJoin(
-      this._table,
-      this._session,
-      this._filter,
-      join,
-      this.props,
-      this.__orderBy,
-      this.__order,
-      this.__distinct,
-      this.__partial,
-      partial,
-    );
-  }
-
-  public fullJoin<TColumn extends ColumnType, TToColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(
-    table: { new(db: DB): IToTable ;},
-    from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean>,
-    to: (table: IToTable) => AbstractColumn<TToColumn, boolean, boolean>,
-    partial?: IToPartial,
-  ): SelectTRBWithJoin<TTable, IToTable, TPartial, IToPartial> {
-    const toTable = this._table.db.create(table);
-
-    const fromColumn = from(this._table);
-    const toColumn = to(toTable);
-
-    const join = new JoinWith(toTable.tableName(), toTable.mapServiceToDb())
-      .columns(fromColumn, toColumn).joinStrategy(JoinStrategy.FULL_JOIN);
-
-    return new SelectTRBWithJoin(
-      this._table,
-      this._session,
-      this._filter,
-      join,
-      this.props,
-      this.__orderBy,
-      this.__order,
-      this.__distinct,
-      this.__partial,
-      partial,
-    );
-  }
-
-  public execute = async () => {
-    const res = await this._execute();
-    return res;
-  };
-
-  protected _execute = async (): Promise<Array<[keyof TPartial] extends [never] ? ExtractModel<TTable>: ExtractModel<TPartial>>> => {
-    // Select.from().filteredBy().limit().offset().orderBy().groupBy().build()
-    const queryBuilder = Select
-      .from(this._table, this.__partial)
-      .distinct(this.__distinct)
-      .filteredBy(this._filter)
-      .limit(this.props.limit)
-      .offset(this.props.offset)
-      .orderBy(this.__orderBy, this.__order!);
-
-    let query = '';
-    let values = [];
-    try {
-      const builderResult = queryBuilder.build();
-      query = builderResult.query;
-      values = builderResult.values;
-    } catch (e: any) {
-      throw new BuilderError(BuilderType.SELECT, this._table.tableName(),
-        this._columns, e, this._filter);
-    }
-
-    if (this._logger) {
-      this._logger.info(`Selecting from ${this._table.tableName()} using query:\n ${query}`);
-    }
-    const result = await this._session.execute(query, values);
-    if (this.__partial) {
-      return QueryResponseMapper.partialMap(this.__partial, result) as Array<[keyof TPartial] extends [never] ? ExtractModel<TTable>: ExtractModel<TPartial>>;
-    }
-    return QueryResponseMapper.map(this._mappedServiceToDb, result) as Array<[keyof TPartial] extends [never] ? ExtractModel<TTable>: ExtractModel<TPartial>>;
-  };
-}

package/src/builders/highLvlBuilders/updateRequestBuilder.ts

@@ -1,80 +0,0 @@
-/* eslint-disable max-len */
-import { AbstractColumn } from '../../columns/column';
-import ColumnType from '../../columns/types/columnType';
-import { ISession } from '../../db/session';
-import BuilderError, { BuilderType } from '../../errors/builderError';
-import BaseLogger from '../../logger/abstractLogger';
-import QueryResponseMapper from '../../mappers/responseMapper';
-import { AbstractTable } from '../../tables';
-import { ExtractModel, ExtractUpdateModel } from '../../tables/inferTypes';
-import Update from '../lowLvlBuilders/updates/update';
-import { combine, set } from '../requestBuilders/updates/static';
-import { UpdateCustomExpr, UpdateExpr } from '../requestBuilders/updates/updates';
-import Expr from '../requestBuilders/where/where';
-import TableRequestBuilder from './abstractRequestBuilder';
-
-export default class UpdateTRB<TTable extends AbstractTable<TTable>, TPartial extends {[name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, TTable>} = {}>
-  extends TableRequestBuilder<TTable, TPartial> {
-  private _filter: Expr;
-  private _update: UpdateExpr;
-  private _objToUpdate: Partial<ExtractModel<TTable>>;
-
-  public constructor(
-    table: AbstractTable<TTable>,
-    session: ISession,
-    mappedServiceToDb: { [name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>; },
-    logger?: BaseLogger,
-  ) {
-    super(table, session, mappedServiceToDb, logger);
-  }
-
-  public where = (expr: Expr): UpdateTRB<TTable> => {
-    this._filter = expr;
-    return this;
-  };
-
-  public set = (expr: Partial<ExtractUpdateModel<TTable>>): UpdateTRB<TTable> => {
-    const updates: Array<UpdateExpr> = [];
-    Object.entries(expr).forEach(([key, value]) => {
-      const column = this._mappedServiceToDb[key as keyof ExtractModel<TTable>];
-      if (value instanceof UpdateCustomExpr) {
-        value.setColumn(column);
-        updates.push(value);
-      } else {
-        updates.push(set(column, value as any));
-      }
-    });
-    this._update = combine(updates);
-
-    return this;
-  };
-
-  public execute = async () => {
-    await this._execute();
-  };
-
-  protected _execute = async (): Promise<Array<[keyof TPartial] extends [never] ? ExtractModel<TTable>: ExtractModel<TPartial>>> => {
-    let query = '';
-    let values = [];
-
-    try {
-      const builderResult = Update.in(this._table)
-        .columns()
-        .set(this._update)
-        .filteredBy(this._filter)
-        .build();
-      query = builderResult.query;
-      values = builderResult.values;
-    } catch (e: any) {
-      throw new BuilderError(BuilderType.UPDATE, this._table.tableName(),
-        this._columns, e, this._filter);
-    }
-
-    if (this._logger) {
-      this._logger.info(`Updating ${this._table.tableName()} using query:\n ${query}`);
-      console.log(values);
-    }
-    const result = await this._session.execute(query, values);
-    return QueryResponseMapper.map(this._mappedServiceToDb, result) as Array<[keyof TPartial] extends [never] ? ExtractModel<TTable>: ExtractModel<TPartial>>;
-  };
-}

package/src/builders/index.ts

@@ -1,21 +0,0 @@
-/* eslint-disable import/no-cycle */
-export { default as DeleteTRB } from './highLvlBuilders/deleteRequestBuilder';
-export { default as InsertTRB } from './highLvlBuilders/insertRequestBuilder';
-export { default as SelectTRB } from './highLvlBuilders/selectRequestBuilder';
-export { default as UpdateTRB } from './highLvlBuilders/updateRequestBuilder';
-export { default as to } from './joinBuilders/static';
-export { default as JoinWith } from './joinBuilders/joinWith';
-export { default as Join } from './joinBuilders/join';
-export { default as SelectTRBWithJoin } from './joinBuilders/builders/selectWithJoin';
-export { default as SelectTRBWithTwoJoins } from './joinBuilders/builders/selectWithTwoJoins';
-export { default as SelectResponseTwoJoins } from './joinBuilders/responses/selectResponseTwoJoins';
-export { default as SelectResponseJoin } from './joinBuilders/responses/selectResponseWithJoin';
-export { default as Create } from './lowLvlBuilders/create';
-export { default as Delete } from './lowLvlBuilders/delets/delete';
-export { default as Insert } from './lowLvlBuilders/inserts/insert';
-export { default as Select } from './lowLvlBuilders/selects/select';
-export { default as Update } from './lowLvlBuilders/updates/update';
-export { set, combine } from './requestBuilders/updates/static';
-export {
-  eq, inArray as in, and, or, like, greater, greaterEq, less, lessEq, raw, isNotNull,
-} from './requestBuilders/where/static';

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

@@ -1,98 +0,0 @@
-/* eslint-disable max-len */
-import { QueryResult } from 'pg';
-import { AbstractColumn } from '../../../columns/column';
-import ColumnType from '../../../columns/types/columnType';
-import { ISession } from '../../../db/session';
-import BuilderError, { BuilderType } from '../../../errors/builderError';
-import QueryResponseMapper from '../../../mappers/responseMapper';
-import { AbstractTable } from '../../../tables';
-import { ExtractModel, FullOrPartial, PartialFor } from '../../../tables/inferTypes';
-import Order from '../../highLvlBuilders/order';
-import Select from '../../lowLvlBuilders/selects/select';
-import Expr from '../../requestBuilders/where/where';
-import Join from '../join';
-
-export default abstract class AbstractJoined<TTable extends AbstractTable<TTable>, TRes, TPartial extends PartialFor<TTable> = {}> {
-  protected _table: TTable;
-  protected _session: ISession;
-  protected _filter: Expr;
-  protected _distinct?: AbstractColumn<ColumnType, boolean, boolean>;
-  protected _props: {limit?:number, offset?:number};
-  protected _orderBy?: AbstractColumn<ColumnType, boolean, boolean>;
-  protected _order?: Order;
-  protected _partial?: TPartial;
-
-  public constructor(
-    table: TTable,
-    filter: Expr,
-    session: ISession,
-    props: { limit?: number, offset?: number },
-    orderBy?: AbstractColumn<ColumnType, boolean, boolean>,
-    order?: Order,
-    distinct?: AbstractColumn<ColumnType, boolean, boolean>,
-    tablePartial?: TPartial,
-  ) {
-    this._table = table;
-    this._session = session;
-    this._filter = filter;
-    this._props = props;
-    this._order = order;
-    this._orderBy = orderBy;
-    this._distinct = distinct;
-    this._partial = tablePartial;
-  }
-
-  public limit = (limit: number) => {
-    this._props.limit = limit;
-    return this;
-  };
-
-  public offset = (offset: number) => {
-    this._props.offset = offset;
-    return this;
-  };
-
-  public execute = async (): Promise<TRes> => {
-    const queryBuilder = Select
-      .from(this._table, this._partial)
-      .distinct(this._distinct)
-      .joined(this.joins())
-      .limit(this._props.limit)
-      .offset(this._props.offset)
-      .filteredBy(this._filter)
-      .orderBy(this._orderBy, this._order);
-
-    let query = '';
-    let values = [];
-    try {
-      const builderResult = queryBuilder.build();
-      query = builderResult.query;
-      values = builderResult.values;
-    } catch (e: any) {
-      throw new BuilderError(BuilderType.JOINED_SELECT,
-        this._table.tableName(), Object.values(this._table.mapServiceToDb()), e, this._filter);
-    }
-
-    console.log(query);
-    console.log(values);
-
-    const result = await this._session.execute(query, values);
-    return this.mapResponse(result);
-  };
-
-  protected fullOrPartial<Table extends AbstractTable<Table>, Partial extends PartialFor<Table>>(mappedServiceToDb: {
-    [name in keyof ExtractModel<Table>]: AbstractColumn<ColumnType>;
-  }, result: QueryResult<any>, partial?: Partial, joinId?: number): Array<FullOrPartial<Table, Partial>> {
-    if (partial) {
-      return QueryResponseMapper.partialMap(partial, result, joinId) as Array<FullOrPartial<Table, Partial>>;
-    }
-    return QueryResponseMapper.map(mappedServiceToDb, result, joinId) as Array<FullOrPartial<Table, Partial>>;
-  }
-
-  protected abstract mapResponse(result: QueryResult<any>): TRes;
-
-  protected abstract joins(): Array<{
-    join: Join<any>, partial?: {[name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, any>},
-    id?: number
-  }>;
-}

package/src/builders/joinBuilders/builders/selectWithFiveJoins.ts

@@ -1,110 +0,0 @@
-/* eslint-disable max-len */
-import { QueryResult } from 'pg';
-import { AbstractColumn } from '../../../columns/column';
-import ColumnType from '../../../columns/types/columnType';
-import { ISession } from '../../../db/session';
-import { AbstractTable } from '../../../tables';
-import { ExtractModel, PartialFor } from '../../../tables/inferTypes';
-import Order from '../../highLvlBuilders/order';
-import Expr from '../../requestBuilders/where/where';
-import Join from '../join';
-import SelectResponseFiveJoins from '../responses/selectResponseFiveJoins';
-import AbstractJoined from './abstractJoinBuilder';
-
-export default class SelectTRBWithFiveJoins<TTable extends AbstractTable<TTable>,
- TTable1 extends AbstractTable<TTable1>, TTable2 extends AbstractTable<TTable2>, TTable3 extends AbstractTable<TTable3>, TTable4 extends AbstractTable<TTable4>, TTable5 extends AbstractTable<TTable5>,
- TPartial extends PartialFor<TTable> = {},
-  TPartial1 extends PartialFor<TTable1> = {},
-  TPartial2 extends PartialFor<TTable2> = {},
-  TPartial3 extends PartialFor<TTable3> = {},
-  TPartial4 extends PartialFor<TTable4> = {},
-  TPartial5 extends PartialFor<TTable5> = {}>
-  extends AbstractJoined<TTable,
-  SelectResponseFiveJoins<TTable, TTable1, TTable2, TTable3, TTable4, TTable5, TPartial, TPartial1, TPartial2, TPartial3, TPartial4, TPartial5>, TPartial> {
-  private _join1: Join<TTable1>;
-  private _join2: Join<TTable2>;
-  private _join3: Join<TTable3>;
-  private _join4: Join<TTable4>;
-  private _join5: Join<TTable5>;
-
-  private _joinedPartial?: TPartial1;
-  private _joinedPartial1?: TPartial2;
-  private _joinedPartial2?: TPartial3;
-  private _joinedPartial3?: TPartial4;
-  private _joinedPartial4?: TPartial5;
-
-  public 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>,
-    tablePartial?: TPartial,
-    joinedPartial?: TPartial1,
-    joinedPartial1?: TPartial2,
-    joinedPartial2?: TPartial3,
-    joinedPartial3?: TPartial4,
-    joinedPartial4?: TPartial5,
-  ) {
-    super(table, filter, session, props, orderBy, order, distinct, tablePartial);
-    this._join1 = join1;
-    this._join2 = join2;
-    this._join3 = join3;
-    this._join4 = join4;
-    this._join5 = join5;
-
-    this._joinedPartial = joinedPartial;
-    this._joinedPartial1 = joinedPartial1;
-    this._joinedPartial2 = joinedPartial2;
-    this._joinedPartial3 = joinedPartial3;
-    this._joinedPartial4 = joinedPartial4;
-  }
-
-  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 },
-      { join: this._join3, partial: this._joinedPartial2, id: 3 },
-      { join: this._join4, partial: this._joinedPartial3, id: 4 },
-      { join: this._join5, partial: this._joinedPartial4, id: 5 }];
-  }
-
-  protected mapResponse(result: QueryResult<any>)
-    : SelectResponseFiveJoins<TTable, TTable1, TTable2, TTable3, TTable4, TTable5, TPartial, TPartial1, TPartial2, TPartial3, TPartial4, TPartial5> {
-    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 parentThree: {
-      [name in keyof ExtractModel<TTable3>]: AbstractColumn<ColumnType>;
-    } = this._join3.mappedServiceToDb;
-    const parentFour:
-    { [name in keyof ExtractModel<TTable4>]: AbstractColumn<ColumnType>;
-    } = this._join4.mappedServiceToDb;
-    const parentFive:
-    { [name in keyof ExtractModel<TTable5>]: AbstractColumn<ColumnType>;
-    } = this._join5.mappedServiceToDb;
-
-    // TODO map ids for join properly
-    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);
-    const objectsThree = this.fullOrPartial(parentThree, result, this._joinedPartial2, 3);
-    const objectsFour = this.fullOrPartial(parentFour, result, this._joinedPartial3, 4);
-    const objectsFive = this.fullOrPartial(parentFive, result, this._joinedPartial4, 5);
-
-    return new SelectResponseFiveJoins(response, objects, objectsTwo,
-      objectsThree, objectsFour, objectsFive);
-  }
-}