type-graphql#ArgsType TypeScript Examples

@ArgsType()
export class editMessageArgs {
  @Field({ nullable: false })
  messageId: ObjectID;

  @Field({ nullable: false })
  @Length(2, 500)
  content: string;
}

@ArgsType()
class TopicsArgs {
  @Field((type) => Int, {
    defaultValue: 100,
  })
  take: number

  @Field((type) => Int, {
    defaultValue: 1,
  })
  page: number
}

@ArgsType()
class CommentsArgs {
  @Field((type) => Int)
  topicId: number

  @Field((type) => Int, {
    defaultValue: 100,
  })
  take: number

  @Field((type) => Int, {
    defaultValue: 1,
  })
  page: number

  @Field((type) => SORT_ORDER, { defaultValue: 'asc' })
  order: 'desc' | 'asc'
}

@ArgsType()
class CreateCommentArgs {
  @Field((type) => Int)
  topicId: number

  @Field()
  content: string

  @Field((type) => Int, {
    nullable: true,
  })
  parentId?: number
}

@ArgsType()
export class setUserLinksArgs {
  @Field({ nullable: true })
  @Length(5, 100)
  @Matches(githubUsernameRegex, { message: "Invalid Github username" })
  public github?: string;

  @Field({ nullable: true })
  @Length(5, 100)
  @Matches(twitterUsernameRegex, { message: "Invalid Twitter username" })
  public twitter?: string;

  @Field({ nullable: true })
  @Matches(instagramUsernameRegex, { message: "Invalid Instagram Link" })
  @Length(5, 150)
  public instagram?: string;

  @Field({ nullable: true })
  @Length(5, 100)
  @IsUrl(
    {
      disallow_auth: true,
      allow_protocol_relative_urls: false,
    },
    { message: "Invalid website URL" }
  )
  public website?: string;
}

@ArgsType()
class CreateTopicArgs {
  @Field()
  title: string

  @Field()
  content: string

  @Field({ nullable: true })
  url?: string
}

@ArgsType()
class UpdateTopicArgs {
  @Field((type) => Int)
  id: number

  @Field({ nullable: true })
  title?: string

  @Field({ nullable: true })
  content?: string

  @Field((type) => Int, { nullable: true })
  nodeId?: number
}

@ArgsType()
export class getMessagesArgs {
  @Field({ nullable: false })
  roomId: ObjectID;

  @Field(type => Int)
  limit: number;

  @Field({ nullable: true })
  before: string;

  @Field({ nullable: true })
  after: string;
}

@ArgsType()
export class sendMessageArgs {
  @Field({ nullable: false })
  roomId: ObjectID;

  @Field({ nullable: false })
  @Length(2, 500)
  content: string;
}

@ArgsType()
export default class TargetDeviceOptionsArgs {
  @Field()
  target: string;

  @Field(() => FirmwareSource)
  source: FirmwareSource;

  @Field()
  gitTag: string;

  @Field()
  gitBranch: string;

  @Field()
  gitCommit: string;

  @Field()
  localPath: string;

  @Field(() => PullRequest)
  gitPullRequest: PullRequest | null;

  constructor() {
    this.source = FirmwareSource.GitBranch;
    this.target = 'DIY_2400_TX_ESP32_SX1280_E28_via_UART';
    this.gitTag = '';
    this.gitBranch = '';
    this.gitCommit = '';
    this.localPath = '';
    this.gitPullRequest = null;
  }
}

@ArgsType()
export default class TargetArgs {
  @Field(() => FirmwareSource)
  source: FirmwareSource;

  @Field()
  gitTag: string;

  @Field()
  gitBranch: string;

  @Field()
  gitCommit: string;

  @Field()
  localPath: string;

  @Field(() => PullRequest)
  gitPullRequest: PullRequest | null;

  constructor() {
    this.source = FirmwareSource.GitBranch;
    this.gitTag = '';
    this.gitBranch = '';
    this.gitCommit = '';
    this.localPath = '';
    this.gitPullRequest = null;
  }
}

@ArgsType()
export default class LuaArgs {
  @Field(() => FirmwareSource)
  source: FirmwareSource;

  @Field()
  gitTag: string;

  @Field()
  gitBranch: string;

  @Field()
  gitCommit: string;

  @Field()
  localPath: string;

  @Field(() => PullRequest)
  gitPullRequest: PullRequest | null;

  constructor() {
    this.source = FirmwareSource.GitBranch;
    this.gitTag = '';
    this.gitBranch = '';
    this.gitCommit = '';
    this.localPath = '';
    this.gitPullRequest = null;
  }
}

@ArgsType()
class StudentArgs {
    @Field({ description: '姓名', nullable: true })
    public name?: string;

    @Field({ description: '性别', nullable: true })
    public sex?: string; // 考虑用enum

    @Field({ description: '年龄', nullable: true })
    public age?: number;

    @Field({ description: 'infoid', nullable: true })
    public info?: string;
}

@ArgsType()
export class setColorArgs {
  @Field({ nullable: false })
  @IsHexColor()
  @Validate(ValidateColor)
  color: string;
}

@ArgsType()
class LikeTopicArgs {
  @Field((type) => Int)
  topicId: number
}

@ArgsType()
class TopicByIdArgs {
  @Field((type) => Int)
  id: number
}

@ArgsType()
class ProfileArgs {
  @Field()
  username: string
}

@ArgsType()
class LikeCommentArgs {
  @Field((type) => Int)
  commentId: number
}

@ArgsType()
    class CreateArgs {
        @Field(() => InputEntityClass ?? String)
        data: EntityInputType;
    }

@ArgsType()
export class removeMembersArgs {
  @Field(type => ObjectID, { nullable: false })
  roomId: ObjectID;

  @Field(type => ObjectID, { nullable: false })
  memberId: ObjectID;
}

@ArgsType()
export class createRoomArgs {
  @Field({ nullable: false })
  @Length(2, 25)
  name: string;
}

@ArgsType()
export class inviteMembersArgs {
  @Field({ nullable: false })
  roomId: ObjectID;

  @Field(() => [ObjectID])
  members: ObjectID[];
}

@ArgsType()
    class UpdateArgs {
        @Field(() => Int)
        id: number;

        @Field(() => InputEntityClass ?? String)
        data: EntityInputType;
    }

createGenericEntity = <EntityType, EntityInputType = EntityType>(entityName: string,
    EntityClass: new (...args: any[]) => EntityType,
    InputEntityClass?: new (...args: any[]) => EntityInputType) => {

    @EntityRepository(EntityClass)
    class GenericRepository extends BaseRepository<EntityType, EntityInputType> {
        constructor() {
            super(EntityClass)
        }
    }

    @ObjectType(`Paged${entityName}`)
    class PagedEntity implements TPagedList<EntityType> {
        @Field(() => PagedMeta, { nullable: true })
        pagedMeta?: PagedMeta;

        @Field(() => [EntityClass], { nullable: true })
        elements?: EntityType[];
    }

    @ArgsType()
    class CreateArgs {
        @Field(() => InputEntityClass ?? String)
        data: EntityInputType;
    }

    @ArgsType()
    class UpdateArgs {
        @Field(() => Int)
        id: number;

        @Field(() => InputEntityClass ?? String)
        data: EntityInputType;
    }

    const getPagedPath = GraphQLPaths.Generic.getManyPaged + entityName;
    const getAllPath = GraphQLPaths.Generic.getMany + entityName;
    const getBySlugPath = GraphQLPaths.Generic.getOneBySlug + entityName;
    const getByIdPath = GraphQLPaths.Generic.getOneById + entityName;
    const createPath = GraphQLPaths.Generic.create + entityName;
    const updatePath = GraphQLPaths.Generic.update + entityName;
    const deletePath = GraphQLPaths.Generic.delete + entityName;
    const getFilteredPath = GraphQLPaths.Generic.getFiltered + entityName;

    @Resolver(EntityClass, { isAbstract: true })
    abstract class GenericResolver {

        private repository = getCustomRepository(GenericRepository)

        @Authorized<TAuthRole>("administrator", "guest", "author")
        @Query(() => PagedEntity)
        async [getPagedPath](@Arg("pagedParams") pagedParams: PagedParamsInput<EntityType>):
            Promise<TPagedList<EntityType>> {
            return this.repository.getPaged(pagedParams);
        }

        @Authorized<TAuthRole>("administrator", "guest", "author")
        @Query(() => [EntityClass])
        async [getAllPath](): Promise<EntityType[]> {
            return this.repository.getAll();
        }

        @Authorized<TAuthRole>("administrator", "guest", "author")
        @Query(() => EntityClass)
        async [getBySlugPath](@Arg("slug") slug: string): Promise<EntityType | undefined> {
            return this.repository.getBySlug(slug);
        }

        @Authorized<TAuthRole>("administrator", "guest", "author")
        @Query(() => EntityClass)
        async [getByIdPath](@Arg("id", () => Int) id: number): Promise<EntityType | undefined> {
            return this.repository.getById(id);
        }

        @Authorized<TAuthRole>("administrator", "guest", "author")
        @Query(() => PagedEntity)
        async [getFilteredPath](
            @Arg("pagedParams", () => PagedParamsInput, { nullable: true }) pagedParams?: PagedParamsInput<EntityType>,
            @Arg("filterParams", () => BaseFilterInput, { nullable: true }) filterParams?: BaseFilterInput,
        ): Promise<TPagedList<EntityType> | undefined> {
            return this.repository.getFilteredEntities(pagedParams, filterParams);
        }

        @Authorized<TAuthRole>("administrator")
        @Mutation(() => EntityClass)
        async [createPath](@Args() { data }: CreateArgs): Promise<EntityType> {
            return this.repository.createEntity(data);
        }

        @Authorized<TAuthRole>("administrator")
        @Mutation(() => EntityClass)
        async [updatePath](@Args() { id, data }: UpdateArgs): Promise<EntityType> {
            return this.repository.updateEntity(id, data);
        }

        @Authorized<TAuthRole>("administrator")
        @Mutation(() => Boolean)
        async [deletePath](@Arg("id", () => Int) id: number): Promise<boolean> {
            return this.repository.deleteEntity(id);
        }

    }

    return {
        abstractResolver: GenericResolver as any,
        repository: GenericRepository as TObjectType<BaseRepository<EntityType, EntityInputType>>,
        pagedEntity: PagedEntity as any,
        createArgs: CreateArgs as any,
        updateArgs: UpdateArgs as any,
    }
}