@chronicstone/array-query

query: <
    T extends GenericObject,
    P extends QueryParams<
        T,
        NestedPaths<T>,
        NestedPathsForType<T, string | number | boolean>
    >
>(
    data: T[],
    params: P
) => QueryResult<T, P>;

type ComparatorMatchMode = Extract<
    FilterMatchMode,
    'between' | 'greaterThan' | 'greaterThanOrEqual' | 'lessThan' | 'lessThanOrEqual'
>;

type FilterMatchMode =
    | 'contains'
    | 'between'
    | 'equals'
    | 'notEquals'
    | 'greaterThan'
    | 'greaterThanOrEqual'
    | 'lessThan'
    | 'lessThanOrEqual'
    | 'exists'
    | 'regex'
    | 'arrayLength'
    | 'objectMatch';

type FilterOptions<Paths extends string = string> =
    | Array<QueryFilterGroup<Paths>>
    | Array<QueryFilter<Paths>>
    | {
          groups: Array<QueryFilterGroup<Paths>>;
          operator: Operator;
      };

type GenericObject = Record<Primitive, unknown>;

type MatchModeCore =
    | {
          matchMode: Exclude<
              FilterMatchMode,
              RegexMatchMode | 'objectMatch' | ComparatorMatchMode
          >;
      }
    | {
          matchMode: ComparatorMatchMode;
          params?: ComparatorParams;
      }
    | {
          matchMode: 'regex';
          params?: RegexParams;
      }
    | {
          matchMode: 'objectMatch';
          params: ObjectMapFilterParams | ((value: any) => ObjectMapFilterParams);
      };

type NestedPaths<T> = T extends Array<infer U>
    ? `${NestedPaths<U>}`
    : T extends object
    ? {
          [K in keyof T & (string | number)]: K extends string
              ? `${K}` | `${K}.${NestedPaths<T[K]>}`
              : never;
      }[keyof T & (string | number)]
    : never;

type NestedPathsForType<T, P> = T extends Array<infer U>
    ? NestedPathsForType<U, P>
    : T extends object
    ? {
          [K in keyof T & (string | number)]: K extends string
              ? T[K] extends P
                  ? `${K}` | `${K}.${NestedPathsForType<T[K], P>}`
                  : T[K] extends object
                  ? `${K}.${NestedPathsForType<T[K], P>}`
                  : string
              : string;
      }[keyof T & (string | number)]
    : string;

type NonObjectMatchMode = Exclude<FilterMatchMode, 'objectMatch'>;

type Operator = 'AND' | 'OR' | (() => 'AND' | 'OR');

type Primitive = string | number | symbol;

type QueryFilter<Paths extends string = string> = {
    key: Paths;
    value: any;
    operator?: Operator;
    condition?: () => boolean;
} & MatchModeCore;

type QueryResult<T extends GenericObject, P extends QueryParams<T>> = P extends {
    limit: number;
}
    ? {
          totalRows: number;
          totalPages: number;
          rows: T[];
          unpaginatedRows: T[];
      }
    : T[];

type RegexMatchMode = Extract<FilterMatchMode, 'regex'>;