feat: add filterhandlers and object ref

Author: Tim Streicher

src/middleware.ts

@@ -1,40 +1,84 @@
-import type {Axios, AxiosInstance} from 'axios'
-import type {DRFAxiosConfig, FilterSetConfig} from './types.js'
+import type {AxiosInstance} from 'axios'
+import type {CustomKeyConfig, DRFAxiosConfig, FSKeyConfig, Filter, FilterHandler, FilterSetConfig} from './types'
+import {DRFFilters} from './types'
 
-function addFilterKey(object: unknown, key: string, value: any) {
-  // @ts-expect-error we don't know the type at this point
+/**
+ * The default config
+ */
+const defaultConfig: DRFAxiosConfig = {
+  filterKey: 'filterSet',
+
+  filterHandlers: undefined,
+
+}
+
+/**
+ *Convenience method to set a filter key.
+ *
+ * @param object
+ * @param key
+ * @param value
+ */
+function addFilterKey(object: Record<string, unknown>, key: string, value: unknown) {
   object[key] = value
 }
 
 /**
  *
- * @param config
+ * @param key
+ * @param data
+ * @param filterHandlers
  */
-export function convertFilterSetConfig(config: FilterSetConfig<any, any, any>) {
-  const conversion = {}
-  for (const key in config) {
-    const entry = config[key]
-    if ('value' in entry) { // plain filter
-      addFilterKey(conversion, key, entry.value)
+function parseFilters(key: string, data: Record<string, any>, filterHandlers?: Record<string, FilterHandler>): Array<Filter> {
+  const filters: Array<Filter> = []
+  for (const filterSuffix in data) {
+    if ('value' in data) { // plain filter
+      filters.push({key, value: data.value})
     }
-    else { // custom or complex filter
-      for (const filterSuffix in entry) {
+    else if (filterHandlers && (filterSuffix in filterHandlers)) {
+      // user set a custom handler for this key, so we give him the data and expect him to return a valid filter.
+      filterHandlers[filterSuffix](filterSuffix, data).forEach((filter) => {
+        filters.push({key: `${key}__${filter.key}`, value: filter.value})
+      })
+    }
+    else {
+      const filterValue = data[filterSuffix]
+      if (
+        !DRFFilters.includes(filterSuffix) // if the filter is part of the drf-filters we can just append it as we know how to handle these
+          && !Array.isArray(filterValue) // arrays are objects as well, but we don't want to go deeper into them as we know how to handle these
+          && typeof filterValue === 'object') {
+        // got some more parsing to do
+        parseFilters(filterSuffix, filterValue as Record<string, unknown>, filterHandlers).forEach((filter) => {
+          filters.push({key: `${key}__${filter.key}`, value: filter.value})
+        })
+      }
+      else {
+        // no complex objects just plain filters
         const filterKey = `${key}__${filterSuffix}`
-        // @ts-expect-error can be any type
-        const filterValue = entry[filterSuffix]
-        addFilterKey(conversion, filterKey, filterValue)
+        filters.push({key: filterKey, value: filterValue})
       }
     }
   }
-  return conversion
+  return filters
 }
 
 /**
- * The default config
+ *
+ * @param config
+ * @param filterSetHandlers
  */
-const defaultConfig: DRFAxiosConfig = {
-  filterKey: 'filterSet',
-
+export function convertFilterSetConfig<D, K extends FSKeyConfig<D> | null, C extends CustomKeyConfig | null>(
+  config: FilterSetConfig<D, K, C>,
+  filterSetHandlers?: Record<string, FilterHandler>,
+) {
+  const conversion = {}
+  for (const key in config) {
+    const entry = config[key]
+    parseFilters(key, entry, filterSetHandlers).forEach((filter) => {
+      addFilterKey(conversion, filter.key, filter.value)
+    })
+  }
+  return conversion
 }
 
 export const applyDRFInterceptor = (axios: AxiosInstance, options: DRFAxiosConfig = defaultConfig) => {
@@ -48,14 +92,11 @@ export const applyDRFInterceptor = (axios: AxiosInstance, options: DRFAxiosConfi
             const filterSet = params[key]
             if (filterSet) {
               delete params[key]
-              const filterSetParams = convertFilterSetConfig(filterSet as FilterSetConfig<any>)
+              const filterSetParams = convertFilterSetConfig(filterSet as FilterSetConfig, options.filterHandlers)
               config.params = {...params, ...filterSetParams}
               break
             }
           }
-          else {
-            // TODO if there is no filter key then we assume that the FilterSetConfig is given per request as an additional parameter to the config
-          }
         }
       }
       return config

src/test/conversion-object-ref.test.ts

@@ -0,0 +1,76 @@
+import {convertFilterSetConfig} from '../middleware'
+import type {FilterSetConfig} from '../types'
+
+interface NumberData {
+  number: number
+  noNumber?: Date
+}
+
+interface Data {
+  data: NumberData
+  text?: string
+  new?: boolean
+}
+
+test('it should convert objects with standard filters', () => {
+  const numberData = {number: 123}
+  const simpleConfig: FilterSetConfig<Data> = {
+    data: {
+      lt: numberData,
+    },
+  }
+  const converted = convertFilterSetConfig(simpleConfig)
+  // eslint-disable-next-line camelcase
+  expect(converted).toEqual({data__lt: numberData})
+})
+
+test('it should convert objects with value filters', () => {
+  const date = new Date()
+  const simpleConfig: FilterSetConfig<Data> = {
+    data: {
+      number: {value: 123},
+      noNumber: {value: date},
+    },
+  }
+  const converted = convertFilterSetConfig(simpleConfig)
+  // eslint-disable-next-line camelcase
+  expect(converted).toEqual({data__number: 123, data__noNumber: date})
+})
+
+test('it should convert complex objects with filters', () => {
+  const simpleConfig: FilterSetConfig<Data> = {
+    data: {
+      number: {lt: 123},
+    },
+  }
+  const converted = convertFilterSetConfig(simpleConfig)
+  // eslint-disable-next-line camelcase
+  expect(converted).toEqual({data__number__lt: 123})
+})
+
+interface FilterSetMapping {
+  data: 'lt' | 'gt' | 'custom1'
+  text: 'lt' | 'exact'
+}
+
+test('it should convert objects with standard filters and a Mapping', () => {
+  const numberData = {number: 123}
+  const simpleConfig: FilterSetConfig<Data, FilterSetMapping> = {
+    data: {
+      number: {custom1: 123},
+    },
+  }
+  const converted = convertFilterSetConfig(simpleConfig)
+  // eslint-disable-next-line camelcase
+  expect(converted).toEqual({data__number__lte: numberData})
+})
+
+test('it should convert complex objects with standard filters', () => {
+  const simpleConfig: FilterSetConfig<Data> = {
+    data: {number: {lt: 123}},
+  }
+  const converted = convertFilterSetConfig(simpleConfig)
+  // eslint-disable-next-line camelcase
+  expect(converted).toEqual({data__number__lt: 123, text: 'string'})
+})
+

src/types.ts

@@ -1,68 +1,84 @@
-export interface FilterSetExact<F> {
+export const DRFFilters = ['in', 'exact', 'lt', 'gt', 'lte', 'gte', 'startswith', 'endswith']
+
+/**
+ *
+ */
+interface NotIn {
+  in?: never
+}
+
+interface NotExact {
+  exact?: never
+}
+
+export interface FilterSetExact<F> extends NotIn {
   exact: F
   startswith?: never
+  endswith?: never
   lte?: never
   gte?: never
   lt?: never
   gt?: never
 }
 
-export interface FilterSetStartsWith<F> {
-  exact?: never
-  startswith?: F
+export interface FilterSetIn<F> extends NotExact {
+  startswith?: never
+  endswith?: never
+  in: Array<F>
   lte?: never
   gte?: never
   lt?: never
   gt?: never
 }
 
+export interface FilterSetAffix<F> extends NotExact, NotIn {
+  startswith?: F
+  endswith?: F
+}
+
 type FilterSetRange<T> =
     (FilterSetRangeLT<T> & FilterSetRangeGTE<T>) | (FilterSetRangeLT<T> & FilterSetRangeGT<T>)
     | (FilterSetRangeLTE<T> & FilterSetRangeGTE<T>) | (FilterSetRangeLTE<T> & FilterSetRangeGT<T>)
     | (FilterSetRangeGT<T> & FilterSetRangeLTE<T>) | (FilterSetRangeGT<T> & FilterSetRangeLT<T>)
     | (FilterSetRangeGTE<T> & FilterSetRangeLTE<T>) | (FilterSetRangeGTE<T> & FilterSetRangeLT<T>)
 
-interface NotExact {
-  exact?: never
-}
-
-interface NotStartsWith {
-  startswith?: never
-}
-
-export interface FilterSetRangeLT<T> extends NotExact, NotStartsWith {
+export interface FilterSetRangeLT<T> extends FilterSetAffix<T> {
   lte?: never
   lt?: T
 }
 
-export interface FilterSetRangeLTE<T> extends NotExact, NotStartsWith {
+export interface FilterSetRangeLTE<T> extends FilterSetAffix<T> {
   lte?: T
   lt?: never
 }
 
-export interface FilterSetRangeGT<T> extends NotExact, NotStartsWith {
+export interface FilterSetRangeGT<T> extends FilterSetAffix<T> {
   gte?: never
   gt?: T
 }
 
-export interface FilterSetRangeGTE<T> extends NotExact, NotStartsWith {
+export interface FilterSetRangeGTE<T> extends FilterSetAffix<T> {
   gte?: T
   gt?: never
 
 }
 
-type FilterSet<T> = FilterSetRange<T> | FilterSetExact<T> | FilterSetStartsWith<T>
+/**
+ * all FilterSets
+ */
+type FilterSet<T> = FilterSetRange<T> | FilterSetExact<T> | FilterSetAffix<T> | FilterSetIn<T>
 
 // Config to exclude certain filters and enable custom filters
-type FSKeyConfig<D> = Partial<Record<keyof D, string>>
+export type FSKeyConfig<D> = Partial<Record<keyof D, string>>
 
-type CustomKeyConfig = {[key: string]: any}
+export type CustomKeyConfig = {[key: string]: unknown}
 & {
   [key in keyof FilterSet<unknown>]?: never
 }
 
-type AllowedFSKeys<D, K extends FSKeyConfig<D>, key extends keyof D> =
-    K[key] extends (string | number | symbol) ? Partial<Record<K[key], D[key]>> : never
+type AllowedFSKeys<D, K extends FSKeyConfig<D>, key extends keyof D, C extends CustomKeyConfig | null> =
+    // we exclude the types from the custom config because they are defined there. If not they might allow wrong types
+        (Exclude<K[key], keyof C> extends (string | number | symbol) ? Partial<Record<Exclude<K[key], keyof C>, D[key]>> : never)
 
 type ConfiguredCustomKeys<D, K extends FSKeyConfig<D>, key extends keyof D, C extends CustomKeyConfig> =
     Extract<keyof C, K[key] extends (string | number | symbol) ? K[key] : never>
@@ -73,7 +89,7 @@ type CustomKey<D, K extends FSKeyConfig<D>, key extends keyof D, C extends Custo
           ConfiguredCustomKeys<D, K, key, C> //
           , C[ConfiguredCustomKeys<D, K, key, C>]
       >
-  >
+>
 
 type CheckCustomKeys<D, K extends FSKeyConfig<D>, key extends keyof D, C extends CustomKeyConfig | null> =
   C extends null ?
@@ -88,7 +104,7 @@ type CheckConfigKeys<D, K extends FSKeyConfig<D>, key extends keyof D, C extends
     key extends keyof K ? // check if there is a FSKeyConfig
         (
           CheckCustomKeys<D, K, key, C>
-          | AllowedFSKeys<D, K, key> // every key that is defined in the config is allowed
+          | AllowedFSKeys<D, K, key, C> // every key that is defined in the config is allowed
         )
       : FilterSet<D[key]> // no config for the key so we take the default combinations
 
@@ -99,9 +115,30 @@ export type FilterSetConfig<D = Record<any, any>, K extends FSKeyConfig<D> | nul
     K extends null ? // check if we have a config
       FilterSet<D[key]> // no config so we take the default combinations for each key
       : CheckConfigKeys<D, Exclude<K, null>, key, C> // check if key is inside the config
+  ) | (
+    D[key] extends Record<any, any> ? // check if the type of the key is a Record, so we add extended references
+      FilterSetConfig<D[key]>
+      : never // no types added otherwise
   )
 }
 
+/**
+ * Internal Representation of a Filter
+ */
+export interface Filter {
+  key: string
+  value: unknown
+}
+
+/**
+ *  @param key: the defined key
+ *  @param data: the enclosing data containing the data of the key as well as other data on the same hierarchy
+ */
+export type FilterHandler = (key: string, data: unknown) => Array<Filter>
+
+/**
+ *
+ */
 export interface DRFAxiosConfig {
 
   /** The name of the key where one can put their FilterSetConfig under.
@@ -110,4 +147,9 @@ export interface DRFAxiosConfig {
    */
   filterKey: string
 
+  /**
+   * A Record which contains for a filter the custom filter handler
+   */
+  filterHandlers?: Record<string, FilterHandler>
+
 }