Cómo realizar una consulta similar TypeORM

Hola chicos, estoy tratando de encontrar todos los resultados que tienen un en ellos. He intentado un par de formas, pero el problema es que nada funciona. Simplemente devuelve una matriz vacía.

var data = await getRepository(User)
  .createQueryBuilder("user")
  .where("user.firstName = %:name%", { name: firstName })
  .getMany();

y algo como esto

var data = await getRepository(User)
  .createQueryBuilder("user")
  .where("user.firstName like %:name%", { name: firstName })
  .getMany();

pero nada funciona. Todos estos me están devolviendo una matriz vacía. alguien me puede ayudar gracias

La forma correcta es:

 var data = await getRepository(User)
                  .createQueryBuilder("user")
                  .where("user.firstName like :name", { name:`%${firstName}%` })
                  .getMany();

TypeORM proporciona fuera de la caja Like función. Ejemplo de sus documentos:

import {Like} from "typeorm";

const loadedPosts = await connection.getRepository(Post).find({
    title: Like("%out #%")
});

en tu caso:

var data = await getRepository(User).find({
    name: Like(`%${firstName}%`)
});

También puede utilizar la función de base de datos para la concatenación. En postgres por ejemplo:

 var data = await getRepository(User)
              .createQueryBuilder("user")
              .where("user.firstName like '%' || :name || '%'", {name: firstName })
              .getMany();

Parece que todas las respuestas al momento de escribir, incluida la respuesta aceptada por pleerock, son vulnerables a la inyección de SQL a menos que la entrada del usuario se haya desinfectado de antemano.

 var data = await getRepository(User)
              .createQueryBuilder("user")
              .where("user.firstName like :name", { name:`%${firstName}%`})
              .getMany();

El hecho de que el código anterior sea válido en TypeORM hace que cualquier consulta de este estilo sea vulnerable a la exfiltración de datos. Imaginando la siguiente consulta similar:

 const data = await getRepository(User)
          .createQueryBuilder("user")
          .where("user.firstName like :name", { name: firstName })
          .getOne();

Datos no desinfectados provenientes del usuario que contienen % personaje enviado a firstName en la consulta anterior (por ejemplo let firstName="%John") permitiría a un usuario filtrar datos potencialmente privados sobre otros usuarios.

Por lo tanto, donde el caso de uso lo permita, uno debería asegurar que cualquier entrada del usuario se desinfecte y se eliminen los caracteres especiales.

Alternativamente, en MySQL, donde el caso de uso exige que estén presentes caracteres especiales en el texto, una búsqueda de texto completo puede ser más apropiada. Sin embargo, esto es más caro de mantener.

Cree una búsqueda de texto completo en la columna relevante y realice una consulta

    export class User {
        @PrimaryGeneratedColumn()
        id: number;

        @Index({fulltext: true})
        @Column()
        name: string;
    }

    const data = await this.repository
         .createQueryBuilder()
         .select()
         .where('MATCH(name) AGAINST (:name IN BOOLEAN MODE)', {name: name})
         .getOne()

var data = await  getRepository(User)
                        .createQueryBuilder("user")
                        .where("user.firstName ILIKE %q, {q:`%${VALUE_HERE}%` })
                .getMany();

Así es como lo hago. Espero eso ayude

usando repositorios lo puse en el dónde por ejemplo :

await this.userRepository.findAndCount({
      relations: ['roles', 'company'],
      where: `(username like '%${seachValue}%' or firstname like '%${seachValue}%' 
      or lastname like '%${seachValue}%' or email like '%${seachValue}%')`,
      order: {
        [sortField]: sortDirection,
      },
    });