typeorm-extensions 1.2.0

package/src/extensions/typed/typed-select/typed-select.extension.ts

@@ -0,0 +1,124 @@
+import { ObjectLiteral, SelectQueryBuilder } from 'typeorm';
+import { KeyHolder, KeyProxyCallback } from '../typeorm-querybuilder.types';
+import { getSqlKey } from '../../../utils/proxy-key.utils';
+
+declare module 'typeorm/query-builder/SelectQueryBuilder' {
+	interface SelectQueryBuilder<Entity> {
+		/**
+		 * Creates SELECT query.
+		 * Replaces all previous selections if they exist.
+		 */
+		selectTyped<Type extends ObjectLiteral = Entity>(
+			this: SelectQueryBuilder<Entity>,
+			selection: KeyProxyCallback<Type>,
+			selectionAliasName?: string
+		): SelectQueryBuilder<Entity>;
+		/**
+		 * Creates SELECT query and selects given data.
+		 * Replaces all previous selections if they exist.
+		 */
+		selectTyped(
+			this: SelectQueryBuilder<Entity>,
+			selection: string | KeyHolder,
+			selectionAliasName?: string
+		): SelectQueryBuilder<Entity>;
+		/**
+		 * Creates SELECT query and selects given data.
+		 * Replaces all previous selections if they exist.
+		 */
+		selectTyped<Type extends ObjectLiteral = Entity>(
+			this: SelectQueryBuilder<Entity>,
+			selection: string[] | KeyHolder[] | Array<KeyProxyCallback<Type>>
+		): SelectQueryBuilder<Entity>;
+
+		/**
+		 * Adds new selection to the SELECT query.
+		 */
+		addSelectTyped<Type extends ObjectLiteral = Entity>(
+			this: SelectQueryBuilder<Entity>,
+			selection: KeyProxyCallback<Type>,
+			selectionAliasName?: string
+		): SelectQueryBuilder<Entity>;
+		/**
+		 * Adds new selection to the SELECT query.
+		 */
+		addSelectTyped(
+			this: SelectQueryBuilder<Entity>,
+			selection: string | KeyHolder,
+			selectionAliasName?: string
+		): SelectQueryBuilder<Entity>;
+		/**
+		 * Adds new selection to the SELECT query.
+		 */
+		addSelectTyped<Type extends ObjectLiteral = Entity>(
+			this: SelectQueryBuilder<Entity>,
+			selection: string[] | KeyHolder[] | Array<KeyProxyCallback<Type>>
+		): SelectQueryBuilder<Entity>;
+	}
+}
+
+SelectQueryBuilder.prototype.selectTyped = function <Entity extends ObjectLiteral, Type extends ObjectLiteral = Entity>(
+	this: SelectQueryBuilder<Entity>,
+	selection?:
+		| string
+		| KeyHolder
+		| KeyProxyCallback<Type>
+		| string[]
+		| KeyHolder[]
+		| Array<KeyProxyCallback<Type>>,
+	selectionAliasName?: string
+): SelectQueryBuilder<Entity> {
+	return attachSelectMethod<Entity, Type>(this, 'select', selection, selectionAliasName);
+};
+
+SelectQueryBuilder.prototype.addSelectTyped = function <
+	Entity extends ObjectLiteral,
+	Type extends ObjectLiteral = Entity
+>(
+	this: SelectQueryBuilder<Entity>,
+	selection?:
+		| string
+		| KeyHolder
+		| KeyProxyCallback<Type>
+		| string[]
+		| KeyHolder[]
+		| Array<KeyProxyCallback<Type>>,
+	selectionAliasName?: string
+): SelectQueryBuilder<Entity> {
+	return attachSelectMethod<Entity, Type>(this, 'addSelect', selection, selectionAliasName);
+};
+
+const attachSelectMethod = <Entity extends ObjectLiteral, Type extends ObjectLiteral = Entity>(
+	query: SelectQueryBuilder<Entity>,
+	method: 'select' | 'addSelect',
+	selection?:
+		| string
+		| KeyHolder
+		| KeyProxyCallback<Type>
+		| string[]
+		| KeyHolder[]
+		| Array<KeyProxyCallback<Type>>,
+	selectionAliasName?: string
+): SelectQueryBuilder<Entity> => {
+	if (selection instanceof KeyHolder) {
+		return query[method](selection.toSql(), selectionAliasName);
+	}
+
+	if (Array.isArray(selection)) {
+		const arrayOfKeys = selection.map((value) => getSqlKey<Type>(value, query.alias) as string);
+
+		return query[method](arrayOfKeys);
+	} else if (typeof selection === 'function') {
+		const keyArrayOrSingleKey = getSqlKey<Type>(selection, query.alias);
+
+		if (Array.isArray(keyArrayOrSingleKey)) {
+			return query[method](keyArrayOrSingleKey);
+		}
+
+		return query[method](keyArrayOrSingleKey, selectionAliasName);
+	} else if (typeof selection === 'string') {
+		return query[method](selection, selectionAliasName);
+	}
+
+	return query;
+};

package/src/extensions/typed/typed-where/typed-where.extension.ts

@@ -0,0 +1,268 @@
+import {
+  ObjectLiteral,
+  SelectQueryBuilder,
+  WhereExpressionBuilder,
+  UpdateQueryBuilder,
+  DeleteQueryBuilder,
+} from 'typeorm';
+import { ColumnValueType } from '../typeorm.types';
+import { getSqlKey } from '../../../utils/proxy-key.utils';
+
+export interface TypedWhereOptions {
+  useDoubleQuotes?: boolean;
+}
+
+declare module 'typeorm/query-builder/WhereExpressionBuilder' {
+  interface WhereExpressionBuilder {
+    /**
+     * Sets WHERE condition in the query builder.
+     * If you had previously WHERE expression defined,
+     * calling this function will override previously set WHERE conditions.
+     * Additionally you can add parameters used in where expression.
+     */
+    whereTyped<Type extends ObjectLiteral>(
+      subQuery: (proxy: Type) => ColumnValueType,
+      conditions: string,
+      parameters?: ObjectLiteral,
+      options?: TypedWhereOptions
+    ): this;
+
+    /**
+     * Adds new AND WHERE condition in the query builder.
+     * Additionally you can add parameters used in where expression.
+     */
+    andWhereTyped<Type extends ObjectLiteral>(
+      subQuery: (proxy: Type) => ColumnValueType,
+      conditions: string,
+      parameters?: ObjectLiteral,
+      options?: TypedWhereOptions
+    ): this;
+
+    /**
+     * Adds new OR WHERE condition in the query builder.
+     * Additionally you can add parameters used in where expression.
+     */
+    orWhereTyped<Type extends ObjectLiteral>(
+      subQuery: (proxy: Type) => ColumnValueType,
+      conditions: string,
+      parameters?: ObjectLiteral,
+      options?: TypedWhereOptions
+    ): this;
+  }
+}
+
+declare module 'typeorm/query-builder/SelectQueryBuilder' {
+  interface SelectQueryBuilder<Entity> {
+    /**
+     * Sets WHERE condition in the query builder.
+     * If you had previously WHERE expression defined,
+     * calling this function will override previously set WHERE conditions.
+     * Additionally you can add parameters used in where expression.
+     */
+    whereTyped<Type extends ObjectLiteral = Entity>(
+      where: (proxy: Type) => ColumnValueType,
+      conditions: string,
+      parameters?: ObjectLiteral,
+      options?: TypedWhereOptions
+    ): this;
+
+    /**
+     * Adds new AND WHERE condition in the query builder.
+     * Additionally you can add parameters used in where expression.
+     */
+    andWhereTyped<Type extends ObjectLiteral = Entity>(
+      where: (proxy: Type) => ColumnValueType,
+      conditions: string,
+      parameters?: ObjectLiteral,
+      options?: TypedWhereOptions
+    ): this;
+
+    /**
+     * Adds new OR WHERE condition in the query builder.
+     * Additionally you can add parameters used in where expression.
+     */
+    orWhereTyped<Type extends ObjectLiteral = Entity>(
+      where: (proxy: Type) => ColumnValueType,
+      conditions: string,
+      parameters?: ObjectLiteral,
+      options?: TypedWhereOptions
+    ): this;
+  }
+}
+
+declare module 'typeorm/query-builder/UpdateQueryBuilder' {
+  interface UpdateQueryBuilder<Entity> {
+    /**
+     * Sets WHERE condition in the query builder.
+     * If you had previously WHERE expression defined,
+     * calling this function will override previously set WHERE conditions.
+     * Additionally you can add parameters used in where expression.
+     */
+    whereTyped<Type extends ObjectLiteral = Entity>(
+      where: (proxy: Type) => ColumnValueType,
+      conditions: string,
+      parameters?: ObjectLiteral,
+      options?: TypedWhereOptions
+    ): this;
+
+    /**
+     * Adds new AND WHERE condition in the query builder.
+     * Additionally you can add parameters used in where expression.
+     */
+    andWhereTyped<Type extends ObjectLiteral = Entity>(
+      where: (proxy: Type) => ColumnValueType,
+      conditions: string,
+      parameters?: ObjectLiteral,
+      options?: TypedWhereOptions
+    ): this;
+
+    /**
+     * Adds new OR WHERE condition in the query builder.
+     * Additionally you can add parameters used in where expression.
+     */
+    orWhereTyped<Type extends ObjectLiteral = Entity>(
+      where: (proxy: Type) => ColumnValueType,
+      conditions: string,
+      parameters?: ObjectLiteral,
+      options?: TypedWhereOptions
+    ): this;
+  }
+}
+
+declare module 'typeorm/query-builder/DeleteQueryBuilder' {
+  interface DeleteQueryBuilder<Entity> {
+    /**
+     * Sets WHERE condition in the query builder.
+     * If you had previously WHERE expression defined,
+     * calling this function will override previously set WHERE conditions.
+     * Additionally you can add parameters used in where expression.
+     */
+    whereTyped<Type extends ObjectLiteral = Entity>(
+      where: (proxy: Type) => ColumnValueType,
+      conditions: string,
+      parameters?: ObjectLiteral,
+      options?: TypedWhereOptions
+    ): this;
+
+    /**
+     * Adds new AND WHERE condition in the query builder.
+     * Additionally you can add parameters used in where expression.
+     */
+    andWhereTyped<Type extends ObjectLiteral = Entity>(
+      where: (proxy: Type) => ColumnValueType,
+      conditions: string,
+      parameters?: ObjectLiteral,
+      options?: TypedWhereOptions
+    ): this;
+
+    /**
+     * Adds new OR WHERE condition in the query builder.
+     * Additionally you can add parameters used in where expression.
+     */
+    orWhereTyped<Type extends ObjectLiteral = Entity>(
+      where: (proxy: Type) => ColumnValueType,
+      conditions: string,
+      parameters?: ObjectLiteral,
+      options?: TypedWhereOptions
+    ): this;
+  }
+}
+
+const queryBuilders = [
+  SelectQueryBuilder,
+  UpdateQueryBuilder,
+  DeleteQueryBuilder,
+];
+
+const extension = {
+  prototype: {
+    whereTyped: function <
+      Entity extends ObjectLiteral,
+      Type extends ObjectLiteral = Entity
+    >(
+      this: SelectQueryBuilder<Entity>,
+      where: (proxy: Type) => ColumnValueType,
+      conditions: string,
+      parameters?: ObjectLiteral,
+      options?: TypedWhereOptions
+    ): SelectQueryBuilder<Entity> {
+      return attachWhere<Type, SelectQueryBuilder<Entity>>(
+        this,
+        'where',
+        where,
+        conditions,
+        parameters,
+        options
+      );
+    },
+    andWhereTyped: function <
+      Entity extends ObjectLiteral,
+      Type extends ObjectLiteral = Entity
+    >(
+      this: SelectQueryBuilder<Entity>,
+      where: (proxy: Type) => ColumnValueType,
+      conditions: string,
+      parameters?: ObjectLiteral,
+      options?: TypedWhereOptions
+    ): SelectQueryBuilder<Entity> {
+      return attachWhere<Type, SelectQueryBuilder<Entity>>(
+        this,
+        'andWhere',
+        where,
+        conditions,
+        parameters,
+        options
+      );
+    },
+    orWhereTyped: function <
+      Entity extends ObjectLiteral,
+      Type extends ObjectLiteral = Entity
+    >(
+      this: SelectQueryBuilder<Entity>,
+      where: (proxy: Type) => ColumnValueType,
+      conditions: string,
+      parameters?: ObjectLiteral,
+      options?: TypedWhereOptions
+    ): SelectQueryBuilder<Entity> {
+      return attachWhere<Type, SelectQueryBuilder<Entity>>(
+        this,
+        'orWhere',
+        where,
+        conditions,
+        parameters,
+        options
+      );
+    },
+  },
+};
+
+queryBuilders.forEach((builder) => {
+	Object.assign(builder, extension);
+});
+
+type WhereMethod = 'where' | 'andWhere' | 'orWhere';
+
+function attachWhere<
+  Type extends ObjectLiteral,
+  Q extends WhereExpressionBuilder = WhereExpressionBuilder
+>(
+  builder: Q,
+  method: WhereMethod,
+  where: (proxy: Type) => ColumnValueType,
+  conditions: string,
+  parameters?: ObjectLiteral,
+  options?: TypedWhereOptions
+): Q {
+  if (typeof where === 'function') {
+    const key = getSqlKey<Type>(
+      where,
+      (builder as unknown as SelectQueryBuilder<Type>).alias,
+      options?.useDoubleQuotes
+    );
+
+    // .andWhere(`"table"."column"   IN (:...values)`, { values: ['value'] })
+    return builder[method](`${key} ${conditions}`, parameters);
+  }
+
+  return builder;
+}

package/src/extensions/typed/typeorm-querybuilder.types.ts

@@ -0,0 +1,75 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { ObjectLiteral } from 'typeorm';
+import { ColumnValueType, EntityOnlyWithRelations, EntityWithoutRelations } from './typeorm.types';
+
+export class KeyHolder {
+	constructor(public keys: string[] = []) {
+		this.keys = [...keys];
+	}
+
+	toSql(length: number = 2, addDobleQuotes = true) {
+		const string = this.toString(length);
+		const sql = addDobleQuotes ? `"${string.replace(/\./g, '"."')}"` : string;
+
+		return sql;
+	}
+
+	toString(length = 2) {
+		const keys = this.keys.slice(0, length);
+		const string = keys.join('.');
+
+		return string;
+	}
+
+	valueOf() {
+		return this.toString();
+	}
+
+	[Symbol.toPrimitive]() {
+		return this.toString();
+	}
+
+	add(key: string | symbol) {
+		if (
+			typeof key !== 'symbol' &&
+			!Object.getOwnPropertyNames(this).includes(key) && // check of getOwnPropertyNames(this) is questionable
+			!Object.getOwnPropertyNames(KeyHolder.prototype).includes(key)
+		) {
+			this.keys.push(key);
+		}
+
+		return this;
+	}
+}
+
+export class TypedProxy {
+	public static defaultHandler = {};
+
+	public static create<T extends ObjectLiteral>(obj: object, handler = TypedProxy.defaultHandler) {
+		return new Proxy(obj, handler) as T;
+	}
+}
+
+export class KeyProxy {
+	public static defaultHandler: ProxyHandler<KeyHolder> = {
+		get(target, key, receiver) {
+			// for each key create new independent layer of KeyProxy
+			const newKeyHolder = new KeyHolder(target.keys).add(key);
+			const newLayer = TypedProxy.create<ObjectLiteral>(newKeyHolder, KeyProxy.defaultHandler);
+
+			return Reflect.get(target, key, receiver) ?? newLayer;
+		},
+	};
+
+	public static create<T extends ObjectLiteral>() {
+		return TypedProxy.create<T>(new KeyHolder(), KeyProxy.defaultHandler);
+	}
+}
+
+export type KeyProxyCallback<T extends ObjectLiteral> = (proxy: T) => ColumnValueType | Array<ColumnValueType>;
+export type RelationalKeyProxyCallback<T extends ObjectLiteral> = (
+	proxy: EntityOnlyWithRelations<T>
+) => ColumnValueType;
+export type NonRelationalKeyProxyCallback<T extends ObjectLiteral> = (
+	proxy: EntityWithoutRelations<T>
+) => ColumnValueType;

package/src/extensions/typed/typeorm.types.ts

@@ -0,0 +1,30 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { BaseEntity, ObjectLiteral } from 'typeorm';
+
+export type SimpleColumnType = string | number | boolean | Date | null;
+
+export type ColumnValueType = SimpleColumnType | undefined | object | ObjectLiteral | ':value';
+
+export type RelationColumnsType<ColumnType, Key> = ColumnType extends SimpleColumnType | ((...args: any[]) => any)
+	? never
+	: ColumnType extends BaseEntity | BaseEntity[] | ObjectLiteral | ObjectLiteral[]
+	? Key
+	: never;
+export type NonRelationColumnsType<ColumnType, Key> = ColumnType extends SimpleColumnType ? Key : never;
+
+export type RelationPropertyNames<Type> = {
+	[Key in keyof Type]: RelationColumnsType<Type[Key], Key>;
+}[keyof Type] &
+	string;
+export type NonRelationPropertyNames<Type> = {
+	[Key in keyof Type]: NonRelationColumnsType<Type[Key], Key>;
+}[keyof Type] &
+	string;
+
+export type EntityOnlyWithRelations<Entity extends ObjectLiteral> = {
+	[Key in RelationPropertyNames<Entity>]: Entity[Key];
+};
+
+export type EntityWithoutRelations<Entity extends ObjectLiteral> = {
+	[Key in NonRelationPropertyNames<Entity>]: Entity[Key];
+};

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './extensions';
+
+export * from './types/interfaces';

package/src/types/interfaces/index.ts

@@ -0,0 +1,2 @@
+export * from './ordering.interface';
+export * from './pagination.interface';

package/src/types/interfaces/ordering.interface.ts

@@ -0,0 +1,21 @@
+import { NonFunctionPropertyNames } from "../util-types";
+
+export type OrderDirection = 'asc' | 'desc' | 'ASC' | 'DESC';
+
+export type NullsOrder = 'first' | 'last' | 'FIRST' | 'LAST';
+
+export type OrderParam<Entity> = {
+  field: NonFunctionPropertyNames<Required<Entity>> | string;
+  direction?: OrderDirection;
+  nulls?: NullsOrder;
+};
+
+export type OrderType = {
+	selector: string;
+  order: 'ASC' | 'DESC';
+  nulls?: 'NULLS FIRST' | 'NULLS LAST';
+};
+
+export interface OrderFilter<Entity> {
+  orderBy?: Array<OrderParam<Entity>>;
+}

package/src/types/interfaces/pagination.interface.ts

@@ -0,0 +1,8 @@
+export type PageSize = number;
+
+export type PageNumber = number; // 1-based index
+
+export interface PaginationFilter {
+  page?: PageNumber;
+  pageSize?: PageSize;
+}

package/src/types/modules/column.types.ts

@@ -0,0 +1,5 @@
+import { ObjectLiteral } from "typeorm";
+
+export type SimpleColumnType = string | number | boolean | Date | null;
+
+export type ColumnValueType = SimpleColumnType | undefined | object | ObjectLiteral;

package/src/types/modules/proxy-types/proxy-callback.types.ts

@@ -0,0 +1,11 @@
+import { ObjectLiteral } from "typeorm";
+import { ColumnValueType } from "../column.types";
+import { EntityOnlyWithRelations, EntityWithoutRelations } from "../relations.types";
+
+export type KeyProxyCallback<T extends ObjectLiteral> = (proxy: T) => ColumnValueType | Array<ColumnValueType>;
+export type RelationalKeyProxyCallback<T extends ObjectLiteral> = (
+	proxy: EntityOnlyWithRelations<T>
+) => ColumnValueType;
+export type NonRelationalKeyProxyCallback<T extends ObjectLiteral> = (
+	proxy: EntityWithoutRelations<T>
+) => ColumnValueType;

package/src/types/modules/relations.types.ts

@@ -0,0 +1,34 @@
+import { BaseEntity, ObjectLiteral } from 'typeorm';
+import { SimpleColumnType } from './column.types';
+
+export type RelationColumnsType<ColumnType, Key> = ColumnType extends
+  | SimpleColumnType
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  | ((...args: any[]) => any)
+  ? never
+  : ColumnType extends
+      | BaseEntity
+      | BaseEntity[]
+      | ObjectLiteral
+      | ObjectLiteral[]
+  ? Key
+  : never;
+export type NonRelationColumnsType<ColumnType, Key> =
+  ColumnType extends SimpleColumnType ? Key : never;
+
+export type RelationPropertyNames<Type> = {
+  [Key in keyof Type]: RelationColumnsType<Type[Key], Key>;
+}[keyof Type] &
+  string;
+export type NonRelationPropertyNames<Type> = {
+  [Key in keyof Type]: NonRelationColumnsType<Type[Key], Key>;
+}[keyof Type] &
+  string;
+
+export type EntityOnlyWithRelations<Entity extends ObjectLiteral> = {
+  [Key in RelationPropertyNames<Entity>]: Entity[Key];
+};
+
+export type EntityWithoutRelations<Entity extends ObjectLiteral> = {
+  [Key in NonRelationPropertyNames<Entity>]: Entity[Key];
+};

package/src/types/util-types/index.ts

@@ -0,0 +1,8 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export type FunctionPropertyNames<T> = { [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never }[keyof T] &
+	string;
+export type NonFunctionPropertyNames<T> = {
+	[K in keyof T]: T[K] extends (...args: any[]) => any ? never : K;
+}[keyof T] &
+	string;
+export type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;

package/src/utils/common.utils.ts

@@ -0,0 +1,2 @@
+export const isNil = (val: unknown): boolean =>
+  typeof val === 'undefined' || val === null;

package/src/utils/identifier.utils.ts

@@ -0,0 +1,60 @@
+import { stringToSQLIdentifier } from './sql.utils';
+
+export class Identifier {
+  private readonly useAlias: boolean;
+
+  constructor(
+    public readonly field: string,
+    public readonly alias?: string,
+    private readonly useDoubleQuotes?: boolean
+  ) {
+    this.useAlias = this.calcUseAlias();
+  }
+
+  fieldAsAlias(): string {
+    if (this.useAlias) {
+      return `${this.fieldSql} AS ${this.aliasSql}`;
+    }
+
+    return this.fieldSql;
+  }
+
+  fieldIdentifier(): string {
+    if (this.useAlias) {
+      return `${this.aliasSql}.${this.fieldSql}`;
+    }
+
+    return this.fieldSql;
+  }
+
+  get aliasSql(): string | undefined {
+    return Identifier.aliasToSql(this.alias, this.useDoubleQuotes);
+  }
+
+  get fieldSql(): string {
+    return Identifier.fieldToSql(this.field, this.useDoubleQuotes);
+  }
+
+  /* PRIVATE */
+
+  private calcUseAlias() {
+    return !!this.alias && !this.field.includes('.');
+  }
+
+  /* STATIC */
+
+  static fieldToSql(field: string, useDoubleQuotes?: boolean): string {
+    return this.toIdentifier(field, useDoubleQuotes);
+  }
+
+  static aliasToSql(
+    alias: string | undefined,
+    useDoubleQuotes?: boolean
+  ): string | undefined {
+    return alias ? this.toIdentifier(alias, useDoubleQuotes) : undefined;
+  }
+
+  static toIdentifier(value: string, useDoubleQuotes?: boolean): string {
+    return useDoubleQuotes ? stringToSQLIdentifier(value) : value;
+  }
+}

package/src/utils/pagination.utils.ts

@@ -0,0 +1,17 @@
+import { defaultPageSize } from "../constants";
+import { PaginationFilter } from "../types/interfaces/pagination.interface";
+
+export const getLimitAndOffset = ({ page, pageSize}: PaginationFilter) => {
+  if (!page || page < 1) {
+    page = 1;
+  }
+
+  if (!pageSize || pageSize < 1) {
+    pageSize = defaultPageSize;
+  }
+
+  const offset = (page >= 1 ? page - 1 : 0) * pageSize;
+  const limit = pageSize;
+
+  return { limit, offset };
+}