drizzle-orm 0.10.25 → 0.10.28

package/src/builders/aggregators/abstractAggregator.ts

@@ -0,0 +1,41 @@
+/* eslint-disable max-len */
+import { AbstractColumn, Column } from '../../columns/column';
+import ColumnType from '../../columns/types/columnType';
+import { AbstractTable } from '../../tables';
+import { ecranate } from '../../utils/ecranate';
+
+// eslint-disable-next-line max-len
+export default class Aggregator {
+  protected _fields: Array<string> = [];
+  protected _table: AbstractTable<any>;
+
+  public constructor(table: AbstractTable<any>, partial?: {[name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, AbstractTable<any>>}) {
+    this._table = table;
+    if (!partial) {
+      this._fields = this.generateSelectArray(this._table.tableName(),
+        Object.values(this._table.mapServiceToDb()));
+    } else {
+      this._fields = this.generateSelectArray(this._table.tableName(),
+        Object.values(partial));
+    }
+  }
+
+  protected generateSelectArray = (table: string, columns: AbstractColumn<ColumnType>[], id?: number) => {
+    const selectFields: string[] = [];
+
+    columns.forEach((field: any) => {
+      if (field instanceof Column) {
+        selectFields.push(' ');
+        selectFields.push(table);
+        selectFields.push('.');
+        selectFields.push(ecranate(field.getColumnName()));
+        selectFields.push(' AS ');
+        selectFields.push(ecranate(`${field.getAlias()}${id ? `_${id}` : ''}`));
+        selectFields.push(',');
+      }
+    });
+
+    selectFields.pop();
+    return selectFields;
+  };
+}

package/src/builders/aggregators/deleteAggregator.ts

@@ -0,0 +1,44 @@
+import { AbstractTable } from '../../tables';
+import Expr from '../requestBuilders/where/where';
+import Aggregator from './abstractAggregator';
+
+export default class DeleteAggregator extends Aggregator {
+  private _from: Array<string> = [];
+  private _filters: Array<string> = [];
+  private _values: Array<any> = [];
+  private _delete: Array<string> = ['DELETE'];
+
+  public constructor(table: AbstractTable<any>) {
+    super(table);
+  }
+
+  public filters = (filters: Expr): DeleteAggregator => {
+    if (filters) {
+      const filterQuery = filters.toQuery();
+      this._filters.push('WHERE ');
+      this._filters.push(filterQuery.query);
+      this._values = filterQuery.values;
+    }
+    return this;
+  };
+
+  public appendFrom = (tableName: string): DeleteAggregator => {
+    this._from.push(' FROM ');
+    this._from.push(tableName);
+    return this;
+  };
+
+  public buildQuery = (): { query: string, values: Array<any> } => {
+    // this._delete.push(this._fields.join(''));
+    this._delete.push('\n');
+    this._delete.push(this._from.join(''));
+    this._delete.push('\n');
+    this._delete.push(this._filters.join(''));
+    this._delete.push('\n');
+    this._delete.push('RETURNING');
+    this._delete.push('\n');
+    this._delete.push(this._fields.join(''));
+
+    return { query: this._delete.join(''), values: this._values };
+  };
+}

package/src/builders/aggregators/insertAggregator.ts

@@ -0,0 +1,120 @@
+/* eslint-disable @typescript-eslint/no-loop-func */
+import { IndexedColumn } from '../../columns/column';
+import { AbstractTable } from '../../tables';
+import { ExtractModel, Indexing } from '../../tables/inferTypes';
+import { UpdateExpr } from '../requestBuilders/updates/updates';
+import Aggregator from './abstractAggregator';
+
+export default class InsertAggregator extends Aggregator {
+  private _onConflict: Array<string> = [];
+  private _columns: Array<string> = [];
+  private _query: Array<string> = [];
+  private _values: Array<any> = [];
+  private _from: Array<string> = [];
+  private _insert: Array<string> = ['INSERT INTO'];
+
+  public constructor(table: AbstractTable<any>) {
+    super(table);
+    this._from.push(' ');
+    this._from.push(table.tableName());
+  }
+
+  public appendColumns = () => {
+    const mapper = this._table.mapServiceToDb();
+    const columns = Object.values(mapper);
+
+    for (let i = 0; i < columns.length; i += 1) {
+      const column = columns[i];
+
+      this._columns.push('"');
+      this._columns.push(column.getColumnName());
+      this._columns.push('"');
+
+      if (i < columns.length - 1) {
+        this._columns.push(', ');
+      }
+    }
+  };
+
+  public appendValues = (values: {[name: string]: any}[]) => {
+    // @TODO Check if values not empty
+    const mapper = this._table.mapServiceToDb();
+
+    let position: number = 0;
+    for (let i = 0; i < values.length; i += 1) {
+      const value = values[i];
+
+      this._query.push('(');
+      const entries = Object.entries(mapper);
+
+      entries.forEach(([key], index) => {
+        const valueToInsert = value[key as keyof ExtractModel<any>];
+        const isKeyExistsInValue = key.toString() in value;
+
+        const column = mapper[key as keyof ExtractModel<any>];
+
+        if (isKeyExistsInValue) {
+          if (valueToInsert !== undefined && valueToInsert !== null) {
+            position += 1;
+            this._query.push(`$${position}`);
+            this._values.push(column.getColumnType().insertStrategy(valueToInsert));
+          } else {
+            this._query.push('null');
+          }
+        } else {
+          this._query.push('DEFAULT');
+        }
+
+        if (index < entries.length - 1) {
+          this._query.push(', ');
+        }
+      });
+
+      if (i < values.length - 1) {
+        this._query.push('),\n');
+      } else {
+        this._query.push(')\n');
+      }
+    }
+  };
+
+  public appendOnConflict = (column: Indexing,
+    updates?: UpdateExpr) => {
+    if (column) {
+      const indexName = column instanceof IndexedColumn
+        ? column.getColumnName() : column.getColumns().map((it) => it.getColumnName()).join(',');
+      this._onConflict.push(`ON CONFLICT (${indexName})\n`);
+      if (updates) {
+        const currentPointerPosition = this._values.length > 0
+          ? this._values.length + 1 : undefined;
+
+        const updatesQuery = updates.toQuery(currentPointerPosition);
+
+        this._onConflict.push('DO UPDATE\n');
+        this._onConflict.push(`SET ${updatesQuery.query}`);
+
+        this._values.push(...updatesQuery.values);
+      } else {
+        this._onConflict.push('DO NOTHING\n');
+      }
+    }
+    return this;
+  };
+
+  public buildQuery = (): { query: string, values: Array<any> } => {
+    this._insert.push(this._from.join(''));
+    this._insert.push(' (');
+    this._insert.push(this._columns.join(''));
+    this._insert.push(') ');
+    this._insert.push('VALUES\n');
+    this._insert.push(this._query.join(''));
+    this._insert.push('\n');
+    this._insert.push(this._onConflict.join(''));
+    this._insert.push('\n');
+    this._insert.push('RETURNING');
+    this._insert.push('\n');
+    this._insert.push(this._fields.join(''));
+
+    return { query: this._insert.join(''), values: this._values };
+  };
+}

package/src/builders/aggregators/selectAggregator.ts

@@ -0,0 +1,163 @@
+/* eslint-disable max-len */
+import { AbstractColumn } from '../../columns/column';
+import ColumnType from '../../columns/types/columnType';
+import { AbstractTable } from '../../tables';
+import { ecranate } from '../../utils/ecranate';
+import Order from '../highLvlBuilders/order';
+import Join from '../joinBuilders/join';
+import Expr from '../requestBuilders/where/where';
+import Aggregator from './abstractAggregator';
+
+export default class SelectAggregator extends Aggregator {
+  private _from: Array<string> = [];
+  private _filters: Array<string> = [];
+  private _select: Array<string> = ['SELECT'];
+  private _join: Array<string> = [];
+  private _limit: Array<string> = [];
+  private _offset: Array<string> = [];
+  private _distinct: Array<string> = [];
+  // private _groupBy: Array<string> = [];
+  private _orderBy: Array<string> = [];
+  private _values: Array<any> = [];
+
+  private _joinCache: {[tableName: string]: string} = {};
+
+  // public constructor(table: AbstractTable<any>);
+  // public constructor(table: AbstractTable<any>, partial: {[name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, AbstractTable<any>>})
+  public constructor(table: AbstractTable<any>, partial?: {[name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, AbstractTable<any>>}) {
+    super(table, partial);
+  }
+
+  public filters = (filters: Expr): SelectAggregator => {
+    if (filters) {
+      const queryBuilder = filters.toQuery(1, this._joinCache);
+      this._filters.push('WHERE ');
+      this._filters.push(queryBuilder.query);
+      this._values = queryBuilder.values;
+    }
+    return this;
+  };
+
+  public limit = (limit?: number): SelectAggregator => {
+    if (limit) {
+      this._limit.push('LIMIT ');
+      this._limit.push(limit.toString());
+    }
+    return this;
+  };
+
+  public offset = (offset?: number): SelectAggregator => {
+    if (offset) {
+      this._offset.push('OFFSET ');
+      this._offset.push(offset.toString());
+    }
+    return this;
+  };
+
+  public orderBy = (column?: AbstractColumn<ColumnType, boolean, boolean>,
+    order?: Order): SelectAggregator => {
+    if (column !== null && column !== undefined) {
+      this._orderBy.push('ORDER BY ');
+      const columnParent = this._joinCache[column.getParent().tableName()] ? this._joinCache[column.getParent().tableName()] : column.getParent().tableName();
+      this._orderBy.push(`${columnParent}.${ecranate(column.getColumnName())} `);
+      this._orderBy.push(Order[order!]);
+    }
+    return this;
+  };
+
+  public distinct = (column?: AbstractColumn<ColumnType, boolean, boolean>): SelectAggregator => {
+    if (column) {
+      this._distinct.push(` DISTINCT ON(${column.getParent().tableName()}.${ecranate(column.getColumnName())}) `);
+    }
+    return this;
+  };
+
+  public appendFrom = (tableName: string): SelectAggregator => {
+    this._from.push('FROM ');
+    this._from.push(tableName);
+    // this._from.push(`${tableName} AS ${tableName}_0`);
+    this._joinCache[tableName] = tableName;
+    return this;
+  };
+
+  // Add select generator for second table also
+  public join = (joins: Array<{
+    join: Join<any>, partial?: {[name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, any>},
+    id?: number
+  }>): SelectAggregator => {
+    // const cache: {[tableName: string]: string} = {};
+    joins.forEach((joinObject: {
+      join: Join<any>, partial?: {[name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, any>},
+      id?: number
+    }) => {
+      if (joinObject) {
+        const tableFrom = joinObject.join.fromColumn.getParentName();
+        const tableTo = joinObject.join.toColumn.getParentName();
+        const { type } = joinObject.join;
+
+        let fromAlias = '';
+        if (this._joinCache[tableFrom]) {
+          fromAlias = this._joinCache[tableFrom];
+        } else {
+          fromAlias = `${tableFrom}${joinObject.id ? `_${joinObject.id}` : ''}`;
+          this._joinCache[tableFrom] = fromAlias;
+        }
+
+        let selectString;
+        if (joinObject.partial) {
+          selectString = this.generateSelectArray(`${tableTo}${joinObject.id ? `_${joinObject.id}` : ''}`, Object.values(joinObject.partial), joinObject.id).join('');
+        } else {
+          selectString = this.generateSelectArray(`${tableTo}${joinObject.id ? `_${joinObject.id}` : ''}`, Object.values(joinObject.join.mappedServiceToDb), joinObject.id).join('');
+        }
+        this._fields.push(', ');
+        this._fields.push(selectString);
+        this._join.push('\n');
+        this._join.push(type);
+        this._join.push(' ');
+        this._join.push(tableTo);
+        this._join.push(' ');
+        this._join.push(`AS ${tableTo}${joinObject.id ? `_${joinObject.id}` : ''}`);
+        this._joinCache[tableTo] = `${tableTo}${joinObject.id ? `_${joinObject.id}` : ''}`;
+        this._join.push('\n');
+        this._join.push('ON ');
+        this._join.push(fromAlias);
+        // if (this._joinCache[tableFrom]) {
+        //   this._join.push(this._joinCache[tableFrom]);
+        // } else {
+        //   this._join.push(tableFrom);
+        //   this._joinCache[tableFrom] = `${tableFrom}${joinObject.id ? `_${joinObject.id}` : ''}`;
+        // }
+        this._join.push('.');
+        this._join.push(joinObject.join.fromColumn.getColumnName());
+        this._join.push(' = ');
+        this._join.push(`${tableTo}${joinObject.id ? `_${joinObject.id}` : ''}`);
+        // this._join.push(toAlias);
+        this._join.push('.');
+        this._join.push(joinObject.join.toColumn.getColumnName());
+      }
+    });
+
+    return this;
+  };
+
+  public buildQuery = (): { query: string, values: Array<any> } => {
+    this._select.push(this._distinct.join(''));
+    this._select.push(this._fields.join(''));
+    this._select.push('\n');
+    this._select.push(this._from.join(''));
+    this._select.push('\n');
+    this._select.push(this._join.join(''));
+    if (this._join.length > 0) {
+      this._select.push('\n');
+    }
+    this._select.push(this._filters.join(''));
+    this._select.push('\n');
+    this._select.push(this._orderBy.join(''));
+    this._select.push('\n');
+    this._select.push(this._limit.join(''));
+    this._select.push('\n');
+    this._select.push(this._offset.join(''));
+
+    return { query: this._select.join(''), values: this._values };
+  };
+}

package/src/builders/aggregators/updateAggregator.ts

@@ -0,0 +1,56 @@
+import { AbstractTable } from '../../tables';
+import { UpdateExpr } from '../requestBuilders/updates/updates';
+import Expr from '../requestBuilders/where/where';
+import Aggregator from './abstractAggregator';
+
+export default class UpdateAggregator extends Aggregator {
+  private _updates: Array<string> = [];
+  private _filters: Array<string> = [];
+  private _from: Array<string> = [];
+  private _values: Array<any> = [];
+  private _update: Array<string> = ['UPDATE'];
+
+  public constructor(table: AbstractTable<any>) {
+    super(table);
+  }
+
+  public where = (filters: Expr): UpdateAggregator => {
+    if (filters) {
+      const currentPointerPosition = this._values.length > 0 ? this._values.length + 1 : undefined;
+      const filterQuery = filters.toQuery(currentPointerPosition);
+
+      this._filters.push('WHERE ');
+      this._filters.push(filterQuery.query);
+
+      this._values.push(...filterQuery.values);
+    }
+    return this;
+  };
+
+  public appendFrom = (tableName: string): UpdateAggregator => {
+    this._from.push(' ');
+    this._from.push(tableName);
+    return this;
+  };
+
+  public set = (updates: UpdateExpr): UpdateAggregator => {
+    const setQuery = updates.toQuery();
+    this._updates.push(`\nSET ${setQuery.query}`);
+    this._values.push(...setQuery.values);
+    return this;
+  };
+
+  public buildQuery = (): { query: string, values: Array<any> } => {
+    this._update.push(this._from.join(''));
+    this._update.push('\n');
+    this._update.push(this._updates.join(''));
+    this._update.push('\n');
+    this._update.push(this._filters.join(''));
+    this._update.push('\n');
+    this._update.push('RETURNING');
+    this._update.push('\n');
+    this._update.push(this._fields.join(''));
+
+    return { query: this._update.join(''), values: this._values };
+  };
+}

package/src/builders/highLvlBuilders/abstractRequestBuilder.ts

@@ -0,0 +1,51 @@
+import { AbstractColumn } from '../../columns/column';
+import ColumnType from '../../columns/types/columnType';
+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>,
+TPartial extends {[name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, TTable>} = {}> {
+  protected _table: TTable;
+  protected _session: ISession;
+  protected _mappedServiceToDb: { [name in keyof ExtractModel<TTable>]
+    : AbstractColumn<ColumnType>; };
+
+  protected _columns: AbstractColumn<ColumnType>[];
+  protected _logger?: BaseLogger;
+
+  public constructor(table: AbstractTable<TTable>,
+    session: ISession,
+    mappedServiceToDb: { [name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>; },
+    logger?: BaseLogger) {
+    this._mappedServiceToDb = mappedServiceToDb;
+    this._table = table as unknown as TTable;
+    this._session = session;
+    this._columns = Object.values(mappedServiceToDb);
+    this._logger = logger;
+  }
+
+  public all = async () => {
+    const res = await this._execute();
+    return res;
+  };
+
+  /**
+   * Current function will return an element only if response is of length 1
+   * If there are more or less than 1 element, will throw an Error
+   */
+  public findOne = async () => {
+    const executionRes = await this._execute();
+    if (executionRes.length > 1) {
+      throw new Error('Request contains more than 1 element');
+    } else if (executionRes.length < 1) {
+      throw new Error('Request contains less than 1 element ');
+    } else {
+      return executionRes[0];
+    }
+  };
+
+  // eslint-disable-next-line max-len
+  protected abstract _execute(): Promise<Array<[keyof TPartial] extends [never] ? ExtractModel<TTable>: ExtractModel<TPartial>>>;
+}

package/src/builders/highLvlBuilders/deleteRequestBuilder.ts

@@ -0,0 +1,59 @@
+/* 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 } from '../../tables/inferTypes';
+import Delete from '../lowLvlBuilders/delets/delete';
+import Expr from '../requestBuilders/where/where';
+import TableRequestBuilder from './abstractRequestBuilder';
+
+export default class DeleteTRB<TTable extends AbstractTable<TTable>, TPartial extends {[name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, TTable>} = {}>
+  extends TableRequestBuilder<TTable, TPartial> {
+  private _filter: Expr;
+
+  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): DeleteTRB<TTable> => {
+    this._filter = expr;
+    return this;
+  };
+
+  public execute = async () => {
+    await this._execute();
+  };
+
+  protected _execute = async (): Promise<Array<[keyof TPartial] extends [never] ? ExtractModel<TTable>: ExtractModel<TPartial>>> => {
+    const queryBuilder = Delete
+      .from(this._table)
+      .filteredBy(this._filter);
+
+    let query = '';
+    let values = [];
+    try {
+      const builderResult = queryBuilder.build();
+      query = builderResult.query;
+      values = builderResult.values;
+    } catch (e: any) {
+      throw new BuilderError(BuilderType.DELETE, this._table.tableName(),
+        this._columns, e, this._filter);
+    }
+
+    if (this._logger) {
+      this._logger.info(`Deleting from ${this._table.tableName()} using query:\n ${query}`);
+    }
+
+    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/highLvlBuilders/insertRequestBuilder.ts

@@ -0,0 +1,75 @@
+/* eslint-disable max-len */
+import { combine, set } from '..';
+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, Indexing } from '../../tables/inferTypes';
+import Insert from '../lowLvlBuilders/inserts/insert';
+import { UpdateExpr } from '../requestBuilders/updates/updates';
+import TableRequestBuilder from './abstractRequestBuilder';
+
+export default class InsertTRB<TTable extends AbstractTable<TTable>, TPartial extends {[name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, TTable>} = {}>
+  extends TableRequestBuilder<TTable, TPartial> {
+  private _values: ExtractModel<TTable>[];
+  private _onConflict: UpdateExpr;
+  private _onConflictField: Indexing;
+
+  public constructor(
+    values: ExtractModel<TTable>[],
+    session: ISession,
+    mappedServiceToDb: { [name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>; },
+    table: AbstractTable<TTable>,
+    logger?: BaseLogger,
+  ) {
+    super(table, session, mappedServiceToDb, logger);
+    this._values = values;
+  }
+
+  public execute = async () => {
+    await this._execute();
+  };
+
+  public onConflict = (
+    callback: (table: TTable) => Indexing,
+    update: Partial<ExtractModel<TTable>>,
+  ): InsertTRB<TTable> => {
+    this._onConflictField = callback(this._table);
+    const updates: Array<UpdateExpr> = [];
+    Object.entries(update).forEach(([key, value]) => {
+      const column = this._mappedServiceToDb[key as keyof ExtractModel<TTable>];
+      updates.push(set(column, value as any));
+    });
+    this._onConflict = combine(updates);
+    return this;
+  };
+
+  protected _execute = async (): Promise<Array<[keyof TPartial] extends [never] ? ExtractModel<TTable>: ExtractModel<TPartial>>> => {
+    if (!this._values) throw Error('Values should be provided firestly\nExample: table.values().execute()');
+
+    const queryBuilder = Insert
+      .into(this._table)
+      .values(this._values)
+      .onConflict(this._onConflict, this._onConflictField);
+
+    let query = '';
+    let values = [];
+    try {
+      const builderResult = queryBuilder.build();
+      query = builderResult.query;
+      values = builderResult.values;
+    } catch (e: any) {
+      throw new BuilderError(BuilderType.INSERT, this._table.tableName(), this._columns, e);
+    }
+
+    if (this._logger) {
+      this._logger.info(`Inserting to ${this._table.tableName()} using query:\n ${query}\n${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/highLvlBuilders/order.ts

@@ -0,0 +1,4 @@
+enum Order {
+  ASC,
+  DESC,
+} export default Order;