Typegraphql + TypeORM: salva / aggiorna un array di entità

Question

Ho un server graphql e una roletabella e vorrei salvare più ruoli all'interno di una mutazione.

Ho cercato molto ma non ho trovato nulla.

Come posso fare qualcosa come:

mutation {
  addRoles (roles: [
    {
      name: "role1",
      description: "role 1"
    },
    {
      name: "role2",
      description: "role 2"
    },
    ...
  ])
}

In altre parole, come implementare addRolese updateRolesrisolvere?

Un ciclo for è l'unica opzione? È possibile salvare tutti i ruoli in una chiamata DB?

Il rolemodello:

@Entity("role")
@ObjectType()
export class Role extends BaseEntity {
  @Field((type) => Number)
  @PrimaryGeneratedColumn()
  readonly id!: number;

  @Field()
  @Column({ length: 64 })
  name!: string;

  @Field({ nullable: true })
  @Column({ length: 512, nullable: true })
  description!: string;
}

E aggiungi e aggiorna il resolver:

@Resolver((of) => Role)
export class RoleResolver {

  @Mutation((returns) => Boolean)
  async addRole(
    @Arg("role") role: AddRoleInput
  ): Promise<Boolean> {
    const roleExists = await Role.count({ name: role.name });
    if (roleExists > 0)
      throw new Error(`Role with name "${role.name}" already exists!`);

    const newRole = Role.create(role);
    await newRole.save();
    return true;
  }

  @Mutation((returns) => Boolean)
  async updateRole(
    @Arg("role") role: UpdateRoleInput
  ): Promise<Boolean> {
    const oldRole = await Role.findOneOrFail(role.id);
    Object.assign(oldRole, role);
    await oldRole.save();
    return true;
  }
}

E AddRoleInputeUpdateRoleInput

@InputType({ description: "New Role Argument" })
export class AddRoleInput implements Partial<Role> {
  @Field()
  name!: string;

  @Field({ nullable: true })
  description?: string;
}

@InputType({ description: "Update Role Argument" })
export class UpdateRoleInput implements Partial<Role> {
  @Field()
  id!: number;

  @Field()
  name!: string;

  @Field({ nullable: true })
  description?: string;
}

Answer 1

L'essenza di ciò che dovrai fare è definire un addRolescampo sul tipo di mutazione nel tuo schema. Per esempio

export const RoleSchema = gql`
  type Role {
    id: Int
    # Other fields omitted for brevity
  }

  extend type Mutation {
    # This should already exist
    addRole(role: AddRoleInput!): Role!

    # To accept multiple Input Types, use the List construct
    addRoles(roles: [AddRoleInput!]!): [Role!]
  }
`;

Quindi definisci addRolesnel tuo resolver e chiama le API appropriate.

Answer 2

Sono riuscito a trovare una risposta per tentativi ed errori. Lo posterò qui nel caso in cui qualcuno avesse lo stesso problema:

@Resolver((of) => Role)
export class RoleResolver {

  @Mutation((returns) => Boolean)
  async addRoles(
    @Arg("roles", type => [AddRoleInput]) roles: AddRoleInput[]
  ): Promise<Boolean> {

    // also checks at front
    const roleExists = await Role.count({
      name: In(roles.map((role) => role.name)),
    });
    if (roleExists > 0)
      throw new Error(`Role name conflict!`);
 
    const newRoles = []
    for (let i=0, i < roles.length, i++) {
        const newRole = Role.create(roles[i]);
        newRoles.push(newRole);
    }

    // this is the solution
    // turns out an entity class can be used to save instances
    // failed to found this in the docs though
    await Role.save(newRoles);

    return true;
  }
...
}

Terrò la taglia aperta nel caso ci siano risposte migliori.