Dynamic Enum Types

[alirezaopmc]

I'm creating a Pagination Based Resolver and trying to make it generic to prevent DRY.

There is an error that I can't find a solution for it except hard-coding and stop being generic.

Error:

Registered enum LogicalOperator
Registered enum ConditionalOperator
Registered enum OrderDirection
Registered enum UserSegmentationFields
Registered enum UserTier
Registered enum UserSegmentationEntityFields
/workspaces/admin/node_modules/type-graphql/build/cjs/schema/schema-generator.js:547
            throw new errors_1.CannotDetermineGraphQLTypeError("input", target.name, propertyName, parameterIndex, argName);
                  ^
CannotDetermineGraphQLTypeError: Cannot determine GraphQL input type for 'field' of 'FieldOrderByArgumentClass' class. Is the value, that is used as its TS type or explicit type, decorated with a proper decorator or is it a proper input value?
    at Function.getGraphQLInputType (/workspaces/admin/node_modules/type-graphql/build/cjs/schema/schema-generator.js:547:19)
    at /workspaces/admin/node_modules/type-graphql/build/cjs/schema/schema-generator.js:294:47
    at Array.reduce (<anonymous>)
    at fields (/workspaces/admin/node_modules/type-graphql/build/cjs/schema/schema-generator.js:292:55)
    at resolveObjMapThunk (/workspaces/admin/node_modules/graphql/type/definition.js:504:40)
    at defineInputFieldMap (/workspaces/admin/node_modules/graphql/type/definition.js:1313:20)
    at GraphQLInputObjectType.getFields (/workspaces/admin/node_modules/graphql/type/definition.js:1276:27)
    at collectReferencedTypes (/workspaces/admin/node_modules/graphql/type/schema.js:395:51)
    at collectReferencedTypes (/workspaces/admin/node_modules/graphql/type/schema.js:396:9)
    at collectReferencedTypes (/workspaces/admin/node_modules/graphql/type/schema.js:391:11)

Code:
src/resolvers/schemas/arguments/search_info.ts:

import { ClassType, Field, InputType } from 'type-graphql';
import {
  ConditionalOperator,
  FieldFilterInterface,
  FieldOrderByInterface,
  FilterInterface,
  LogicalOperator,
  OrderByInterface,
  OrderDirection,
  PaginationArgumentInterface,
} from '../../../common/types/search_info';
import { registerEnumOnce } from '../../../common/utils/type-graphql/enum_register';
import { createEnum } from '../../../common/utils/type-graphql/generic_enum';

export function FieldFilterArgument<T extends object>(classRef: ClassType<T>) {
  const fields = Object.keys(classRef.prototype) as Array<keyof T>;
  const Enum = createEnum(fields);

  registerEnumOnce(Enum, { name: `${classRef.name}Fields` });

  @InputType(`${classRef.name}FieldFilterArgument`)
  abstract class FieldFilterArgumentClass implements FieldFilterInterface<T> {
    @Field(() => Enum)
    field!: keyof T;

    @Field(() => ConditionalOperator)
    operator!: ConditionalOperator;

    @Field(() => [String])
    values!: string[];

    @Field({ nullable: true, defaultValue: false })
    not!: boolean;
  }
  return FieldFilterArgumentClass;
}

export function FilterArgument<T extends object>(classRef: ClassType<T>) {
  const FieldFilterClass = FieldFilterArgument(classRef);

  @InputType(`${classRef.name}FilterArgument`)
  abstract class FilterArgumentClass implements FilterInterface<T> {
    @Field(() => LogicalOperator)
    operator!: LogicalOperator;

    @Field(() => [FilterArgumentClass], { nullable: true, defaultValue: [] })
    filters!: Array<FilterArgumentClass>;

    @Field(() => [FieldFilterClass], { nullable: true, defaultValue: [] })
    fieldFilters!: Array<InstanceType<typeof FieldFilterClass>>;

    @Field({ nullable: true, defaultValue: false })
    not!: boolean;
  }
  return FilterArgumentClass;
}

export function FieldOrderByArgument<T extends object>(classRef: ClassType<T>) {
  const fields = Object.keys(classRef.prototype) as Array<keyof T>;
  const Enum = createEnum(fields);

  registerEnumOnce(Enum, { name: `${classRef.name}Fields` });

  @InputType(`${classRef.name}FieldOrderByArgument`)
  class FieldOrderByArgumentClass implements FieldOrderByInterface<T> {
    @Field(() => Enum)
    field!: keyof T;

    @Field(() => OrderDirection)
    direction!: OrderDirection;
  }
  return FieldOrderByArgumentClass;
}

// SearchOrderArgument Function
export function OrderByArgument<T extends object>(classRef: ClassType<T>) {
  const FieldOrderByArgClass = FieldOrderByArgument(classRef);

  @InputType(`${classRef.name}SearchOrderArgument`)
  class OrderByArgumentClass implements OrderByInterface<T> {
    @Field(() => [FieldOrderByArgClass], { nullable: true, defaultValue: [] })
    fieldsOrder!: InstanceType<typeof FieldOrderByArgClass>[];
  }
  return OrderByArgumentClass;
}

export function PaginationArgument<T extends object>(classRef: ClassType<T>) {
  @InputType(`${classRef.name}SearchPaginationArgs`)
  abstract class PaginationArgumentClass
    implements PaginationArgumentInterface<T>
  {
    @Field()
    limit!: number;

    @Field()
    offset!: number;
  }
  return PaginationArgumentClass;
}

src/common/utils/type-graphql.ts:

export type KeysOf<T> = keyof T;
export type ValuesOf<T> = T[keyof T];

export type EnumType<T> = { [K in KeysOf<T>]: K };

export function createEnum<T>(keys: Array<KeysOf<T>>): EnumType<T> {
  return keys.reduce((acc, key) => {
    acc[key] = key;
    return acc;
  }, {} as EnumType<T>);
}

src/common/utils/type-graphql/enum_register.ts:

import { registerEnumType } from 'type-graphql';
import { EnumConfig } from 'type-graphql/build/typings/decorators/types';

const registeredEnums = new Set<string>();

export function registerEnumOnce<T extends object>(
  enumObj: T,
  enumConfig: EnumConfig<T>,
): void {
  if (!registeredEnums.has(enumConfig.name)) {
    registerEnumType(enumObj, enumConfig);
    registeredEnums.add(enumConfig.name);
    console.info(`Registered enum ${enumConfig.name}`);
  }
}

src/common/types/search_info.ts:

export enum LogicalOperator {
  AND = 'AND',
  OR = 'OR',
}
export enum ConditionalOperator {
  EQ = 'EQ',
  GT = 'GT',
  GTE = 'GTE',
  LT = 'LT',
  LTE = 'LTE',
  LIKE = 'LIKE',
  ILIKE = 'ILIKE',
  IN = 'IN',
  JSON_EQ = 'JSON_EQ',
  JSON_GT = 'JSON_GT',
  JSON_GTE = 'JSON_GTE',
  JSON_LT = 'JSON_LT',
  JSON_LTE = 'JSON_LTE',
  JSON_LIKE = 'JSON_LIKE',
  JSON_ILIKE = 'JSON_ILIKE',
  JSON_IN = 'JSON_IN',
}
export enum OrderDirection {
  ASC = 'ASC',
  DESC = 'DESC',
}
export interface FieldFilterInterface<T> {
  field: keyof T;
  operator: ConditionalOperator;
  values: string[];
  not: boolean;
}
export interface FilterInterface<T> {
  operator: LogicalOperator;
  filters: FilterInterface<T>[];
  fieldFilters: FieldFilterInterface<T>[];
  not: boolean;
}
export interface FieldOrderByInterface<T> {
  field: keyof T;
  direction: OrderDirection;
}
export interface OrderByInterface<T> {
  fieldsOrder: FieldOrderByInterface<T>[];
}
export interface PaginationPageInfoInterface {
  hasNextPage: boolean;
  hasPreviousPage: boolean;
  startCursor?: string;
  endCursor?: string;
}
export interface PaginatedResponseInterface<T> {
  items: T[];
  totalCount: number;
  // edges: EdgeInterface<T>[];
  // pageInfo: PageInfoInterface;
}
export interface PaginationArgumentInterface<T> {
  limit: number;
  offset: number;
  // first?: number;
  // after?: string;
  // last?: number;
  // before?: string;
}
export interface EdgeInterface<T> {
  cursor: string;
  node: T;
}
export interface PageInfoInterface {
  endCursor: string;
  hasNextPage: boolean;
  startCursor: string;
  hasPreviousPage: boolean;
}

[igsion]

I have the same problem