Generic InputType Implementation

[sachaw]

I'm trying to implement a generic input type on my schema to filter enums.
I have tried a few approaches but am falling short, this is what I'm trying to imnplement

Input Type:

@InputType()
export class EnumFilter<T> {
  @Field({ nullable: true })
  equals: T;

  @Field({ nullable: true })
  has: T;

  @Field({ nullable: true })
  hasEvery: T;

  @Field({ nullable: true })
  hasSome: T;

  @Field({ nullable: true })
  isEmpty: boolean;
}

Usage:

@InputType()
export class AuthenticatorFilterWhereInput extends FilterWhereInput {
  @Field({ nullable: true })
  AAGUID: StringFilter;

  @Field({ nullable: true })
  credentialID: BytesFilter;

  @Field({ nullable: true })
  credentialPublicKey: BytesFilter;

  @Field({ nullable: true })
  counter: IntFilter;

  @Field({ nullable: true })
  revoked: boolean;

  @Field(() => EnumFilter<Transport>, { nullable: true })
  transports:  EnumFilter;

  @Field(() => UserFilterWhereInput, { nullable: true })
  user: UserFilterWhereInput;
}

Obviously this won't work, I have attempted the method outlined in the docs, but cannot get it to work. Any assistance would be greatly appreciated.

[MichalLytek]

I have attempted the method outlined in the docs

It's exactly the same approach like in docs:
https://typegraphql.com/docs/generic-types.html

But you only need to use @InputType() 😛

[sachaw]

This is what I have:

export const EnumFilter = <T>(Enum: ClassType<T>) => {
  @InputType({ isAbstract: true })
  abstract class EnumFilterClass<T> {
    @Field(() => Enum, { nullable: true })
    equals: T;

    @Field({ nullable: true })
    isEmpty: boolean;
  }

  return EnumFilterClass;
};

Usage:

@Field(() => EnumFilter, { nullable: true })
  transports: ClassType<typeof EnumFilter>;

It's still throwing a type reflection error, also I'm unsure how to type the return type of the function, since I'm returning a class that's defined in the returning function.

Thanks for the assistance.

[MichalLytek]

Copy the example from docs and replace with @InputType.

Can you see PaginatedResponse<TItem>(TItemClass: ClassType<TItem>) and

// here we use the runtime argument
@Field(type => [TItemClass])
// and here the generic type
items: TItem[];

I can't describe it even simpler. The code examples have comments in every crucial place.

[sachaw]

Thanks, I have gotten closer, however I am unable to use an Enum, only a class. This is the part I am unsure about, this is the case for both InputType and ObjectType,

import { ClassType, Field, ObjectType, Query, registerEnumType, Resolver } from "type-graphql";

export enum RequestScope {
  GLOBAL,
  USER,
}

registerEnumType(RequestScope, {
  name: "RequestScope",
});

export default function AbstractFn<T>(Enum: ClassType<T>) {
  @ObjectType({ isAbstract: true })
  abstract class AbstractFnClass {
    @Field(() => [Enum])
    field: T[];
  }
  return AbstractFnClass;
}

@ObjectType()
export class ExampleField {
  @Field()
  field: string;
}

@ObjectType()
export class ExampleQueryResponse {
  @Field()
  field: EnumFilter;
}

@ObjectType()
class EnumFilter extends AbstractFn(ExampleField) {
  // you can add more fields here if you need
}

@ObjectType()
class EnumFilterNotWorking extends AbstractFn(RequestScope) {
  // you can add more fields here if you need
}

@Resolver()
export class ExampleResolver {
  @Query()
  exampleQuery(): ExampleQueryResponse {
    return {
      field: {
        field: [],
      },
    };
  }
}

The TS error emmited is Argument of type 'typeof RequestScope' is not assignable to parameter of type 'ClassType<unknown>'. Type 'typeof RequestScope' provides no match for the signature 'new (...args: any[]): unknown'.
as the Enum is not a class, So I'm unsure of how to re-type the Enum: ClassType<T> part.

Thanks.

[MichalLytek]

Enum is not a class, right? So try <T extends object>(Enum: object).