feat: add interceptors

packages/core/lib/execution-context.ts

@@ -22,9 +22,10 @@ export class ExecutionContext<
   }
 
   constructor(
-    public readonly buildQueryBuilder: (
-      trx?: Knex.Transaction,
-    ) => Knex.QueryBuilder<TRecord, TResult>,
+    public readonly buildQueryBuilder: () => Knex.QueryBuilder<
+      TRecord,
+      TResult
+    >,
     private readonly _queryBuilder: Knex.QueryBuilder<TRecord, TResult>,
     private readonly _rawBuilder: Knex.RawBuilder<TRecord, TResult>,
     private readonly _constructorRef: Function,

packages/core/lib/interfaces/database-options.interface.ts

@@ -12,4 +12,6 @@ export interface DatabaseOptions<TRecord, TResult> {
 
 export interface SelectDatabaseOptions<TRecord, TResult>
   extends DatabaseOptions<TRecord, TResult>,
-    AliasableRepositoryDatabaseOptions {}
+    AliasableRepositoryDatabaseOptions {
+  [field: string]: unknown;
+}

packages/core/lib/repository.ts

@@ -212,7 +212,7 @@ export class Repository<
     handler?: Function,
   ): Knex.QueryBuilder<TRecord, TResult> {
     const context = new ExecutionContext(
-      (trx?: Knex.Transaction) => this.pureQueryBuilder(trx),
+      () => this.queryBuilder(options, handler),
       queryBuilder,
       this.rawBuilder(options?.transaction),
       this.constructor,

packages/filter/.npmignore

@@ -0,0 +1,6 @@
+*
+!package.json
+!lib/**/*.js
+!index.js
+!index.d.ts
+!*.d.ts

packages/filter/README.md

@@ -0,0 +1,11 @@
+# `@knexion/filter`
+
+> TODO: description
+
+## Usage
+
+```
+const filter = require('@knexion/filter');
+
+// TODO: DEMONSTRATE API
+```

packages/filter/index.ts

@@ -0,0 +1 @@
+export * from './lib';

packages/filter/jest.config.js

@@ -0,0 +1,5 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+};

packages/filter/lib/index.ts

@@ -0,0 +1,2 @@
+export * from './interceptors';
+export * from './interfaces';

packages/filter/lib/interceptors/filter-by-array.interceptor.ts

@@ -0,0 +1,42 @@
+import { Observable } from 'rxjs';
+import {
+  addPrefixColumn,
+  ExecutionContext,
+  RepositoryInterceptor,
+  RepositoryInterceptorNext,
+  SelectDatabaseOptions,
+} from '@knexion/core';
+import { FilterOptions } from '../interfaces';
+
+type FilterByArrayOperator = 'in' | string;
+
+export class FilterByArrayInterceptor<TRecord, TResult>
+  implements RepositoryInterceptor<TRecord, TResult>
+{
+  constructor(
+    private readonly name: keyof TRecord,
+    private readonly value: string[],
+    private readonly operator: FilterByArrayOperator = 'in',
+    private readonly options: FilterOptions = {},
+  ) {}
+
+  public intercept(
+    context: ExecutionContext<
+      TRecord,
+      TResult,
+      SelectDatabaseOptions<TRecord, TResult>
+    >,
+    next: RepositoryInterceptorNext,
+  ): Observable<unknown> {
+    const { useAlias = true } = this.options;
+    const column = useAlias
+      ? addPrefixColumn(this.name as string, context.options.alias)
+      : (this.name as string);
+    if (this.operator === 'in') {
+      context.queryBuilder.whereIn(column, this.value);
+    } else {
+      context.queryBuilder.where(column, this.operator, this.value);
+    }
+    return next.handle();
+  }
+}

packages/filter/lib/interceptors/filter-by-number-range.interceptor.ts

@@ -0,0 +1,35 @@
+import { Observable } from 'rxjs';
+import {
+  addPrefixColumn,
+  ExecutionContext,
+  RepositoryInterceptor,
+  RepositoryInterceptorNext,
+  SelectDatabaseOptions,
+} from '@knexion/core';
+import { buildRangeNumberFilter } from '../utils';
+import { FilterOptions, RangeNumberFilter } from '../interfaces';
+
+export class FilterByNumberRangeInterceptor<TRecord, TResult>
+  implements RepositoryInterceptor<TRecord, TResult>
+{
+  constructor(
+    private readonly name: keyof TRecord,
+    private readonly value: RangeNumberFilter,
+    private readonly options: FilterOptions = {},
+  ) {}
+  public intercept(
+    context: ExecutionContext<
+      TRecord,
+      TResult,
+      SelectDatabaseOptions<TRecord, TResult>
+    >,
+    next: RepositoryInterceptorNext,
+  ): Observable<unknown> {
+    const { useAlias = true } = this.options;
+    const column = useAlias
+      ? addPrefixColumn(this.name as string, context.options.alias)
+      : (this.name as string);
+    buildRangeNumberFilter(context.queryBuilder, column, this.value);
+    return next.handle();
+  }
+}

packages/filter/lib/interceptors/filter-timestamp.interceptor.ts

@@ -0,0 +1,80 @@
+import { Observable } from 'rxjs';
+import { Knex } from 'knex';
+import {
+  addPrefixColumn,
+  ExecutionContext,
+  RepositoryInterceptor,
+  RepositoryInterceptorNext,
+  SelectDatabaseOptions,
+} from '@knexion/core';
+import { RangeNumberFilter, TimestampFilter } from '../interfaces';
+
+export class FilterTimestampInterceptor<TRecord, TResult>
+  implements RepositoryInterceptor<TRecord, TResult>
+{
+  constructor(private readonly timestampField: keyof TRecord) {}
+
+  public intercept(
+    context: ExecutionContext<
+      TRecord,
+      TResult,
+      SelectDatabaseOptions<TRecord, TResult>
+    >,
+    next: RepositoryInterceptorNext,
+  ): Observable<unknown> {
+    if (!context.options[this.timestampField as string]) {
+      return next.handle();
+    }
+    const timestampFilter = context.options[this.timestampField as string];
+    if (this.isNumber(timestampFilter)) {
+      context.queryBuilder.where(
+        addPrefixColumn('created_at', context.options.alias),
+        timestampFilter,
+      );
+    } else {
+      this.buildComplexDateFilterQuery(
+        context.queryBuilder,
+        timestampFilter,
+        context.options,
+      );
+    }
+    return next.handle();
+  }
+
+  private isNumber(dateFilter: number | TimestampFilter): dateFilter is number {
+    return typeof dateFilter === 'number';
+  }
+
+  private buildComplexDateFilterQuery(
+    queryBuilder: Knex.QueryBuilder<TRecord, TResult>,
+    dateFilter: RangeNumberFilter,
+    options: SelectDatabaseOptions<TRecord, TResult>,
+  ): void {
+    Object.entries(dateFilter).forEach(([operator, value]) =>
+      this.getQueryForDateOperator(
+        queryBuilder,
+        operator as 'gt' | 'gte' | 'lt' | 'lte',
+        value,
+        options.alias,
+      ),
+    );
+  }
+
+  private getQueryForDateOperator(
+    queryBuilder: Knex.QueryBuilder<TRecord, TResult>,
+    operator: 'gt' | 'gte' | 'lt' | 'lte',
+    value: number,
+    alias?: string,
+  ): void {
+    const createdAtColumnName = addPrefixColumn('created_at', alias);
+    if (operator === 'gt') {
+      queryBuilder.where(createdAtColumnName, '>', value);
+    } else if (operator === 'gte') {
+      queryBuilder.where(createdAtColumnName, '>=', value);
+    } else if (operator === 'lt') {
+      queryBuilder.where(createdAtColumnName, '<', value);
+    } else if (operator === 'lte') {
+      queryBuilder.where(createdAtColumnName, '<=', value);
+    }
+  }
+}

packages/filter/lib/interceptors/filter.interceptor.ts

@@ -0,0 +1,50 @@
+import { Observable } from 'rxjs';
+import {
+  addPrefixColumn,
+  ExecutionContext,
+  RepositoryInterceptor,
+  RepositoryInterceptorNext,
+  SelectDatabaseOptions,
+} from '@knexion/core';
+import { FilterObject, FilterObjectOptions } from '../interfaces';
+import { isPlainObject } from '@nestjs/common/utils/shared.utils';
+
+export class FilterInterceptor<TRecord, TResult>
+  implements RepositoryInterceptor<TRecord, TResult>
+{
+  constructor(private readonly options: FilterObjectOptions = {}) {}
+
+  public intercept(
+    context: ExecutionContext<
+      TRecord,
+      TResult,
+      SelectDatabaseOptions<TRecord, TResult>
+    >,
+    next: RepositoryInterceptorNext,
+  ): Observable<unknown> {
+    const filterObject = context.options[this.options.optionKey ?? 'filter'];
+    if (isPlainObject(filterObject)) {
+      context.queryBuilder.where(
+        this.appendAliasToFilterColumns(
+          filterObject as FilterObject<TRecord>,
+          context.options.alias,
+        ),
+      );
+    }
+
+    return next.handle();
+  }
+
+  private appendAliasToFilterColumns(
+    filter: Record<string, unknown>,
+    alias?: string,
+  ): Record<string, unknown> {
+    return Object.fromEntries(
+      Object.entries(filter).map(([name, value]) => {
+        const { useAlias = true } = this.options;
+        const column = useAlias ? addPrefixColumn(name, alias) : name;
+        return [column, value];
+      }),
+    );
+  }
+}

packages/filter/lib/interceptors/index.ts

@@ -0,0 +1,4 @@
+export * from './filter.interceptor';
+export * from './filter-by-array.interceptor';
+export * from './filter-by-number-range.interceptor';
+export * from './filter-timestamp.interceptor';

packages/filter/lib/interfaces/filter-options.interface.ts

@@ -0,0 +1,11 @@
+export interface FilterOptions {
+  useAlias?: boolean;
+}
+
+export type FilterObject<TRecord> = Partial<
+  Record<keyof TRecord, string | number | null>
+>;
+
+export interface FilterObjectOptions extends FilterOptions {
+  optionKey?: string;
+}

packages/filter/lib/interfaces/index.ts

@@ -0,0 +1,3 @@
+export * from './filter-options.interface';
+export * from './range-number-filter.interface';
+export * from './timestamp-filter.interface';

packages/filter/lib/interfaces/range-number-filter.interface.ts

@@ -0,0 +1,21 @@
+export interface RangeNumberFilter {
+  /**
+   * Return records where the field is after this value.
+   */
+  gt?: number;
+
+  /**
+   * Return records where the field is after or equal to this value.
+   */
+  gte?: number;
+
+  /**
+   * Return records where the field is before this value.
+   */
+  lt?: number;
+
+  /**
+   * Return records where the field is before or equal to this value.
+   */
+  lte?: number;
+}

packages/filter/lib/interfaces/timestamp-filter.interface.ts

@@ -0,0 +1,3 @@
+import { RangeNumberFilter } from './range-number-filter.interface';
+
+export type TimestampFilter = number | RangeNumberFilter;

packages/filter/lib/utils/build-range-number-filter.ts

@@ -0,0 +1,34 @@
+import { Knex } from 'knex';
+import { RangeNumberFilter } from '../interfaces';
+
+const getQueryForDateOperator = (
+  queryBuilder: Knex.QueryBuilder,
+  name: string,
+  operator: 'gt' | 'gte' | 'lt' | 'lte',
+  value: number,
+): void => {
+  if (operator === 'gt') {
+    queryBuilder.where(name, '>', value);
+  } else if (operator === 'gte') {
+    queryBuilder.where(name, '>=', value);
+  } else if (operator === 'lt') {
+    queryBuilder.where(name, '<', value);
+  } else if (operator === 'lte') {
+    queryBuilder.where(name, '<=', value);
+  }
+};
+
+export const buildRangeNumberFilter = (
+  queryBuilder: Knex.QueryBuilder,
+  name: string,
+  numberFilter: RangeNumberFilter,
+): void => {
+  Object.entries(numberFilter).forEach(([operator, value]) =>
+    getQueryForDateOperator(
+      queryBuilder,
+      name as string,
+      operator as 'gt' | 'gte' | 'lt' | 'lte',
+      value,
+    ),
+  );
+};

packages/filter/lib/utils/index.ts

@@ -0,0 +1 @@
+export * from './build-range-number-filter';