four-eyes's questions

Eu tenho essas entidades

@Entity
@Table(name = "Item")
class Item(
    @Column(name = "name", nullable = false)
    var name: String,

    @Column(name = "added_date", columnDefinition = "TIMESTAMP WITH TIME ZONE", nullable = true)
    var addedDate: ZonedDateTime? = null,

    @Column(name = "duration", nullable = true)
    var duration: Int? = null,

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "head_of_id", nullable = false)
    val headOf: HeadOf,
) {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    var id: Long = 0
}


@Entity
@Table(name = "head_of")
class HeadOf(
    @Column(name = "company", nullable = false)
    var company: String,

    @Column(name = "city", nullable = false)
    var city: String,

    @Column(name = "age", nullable = true)
    var age: Int?
) { 
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    var id: Long = 0
}

e este é o repositório correspondente

interface ItemRepository : JpaRepository<Item, Long> {
    fun findByHeadOfIdAndAddedDateNotNullOrDurationNotNull(
        headOfId: Long,
        position: ScrollPosition,
        pageable: Pageable,
    ): Window<Item>
}

Isto é o que está atualmente na tabela Item. É uma linha (é o resultado de um dump)

INSERT INTO public.item VALUES (1, 'Some fancy title', '2024-12-31 07:14:42.955789+00', NULL, 1000);

Como você pode ver, headOfé 1000L.

Agora, quando eu chamo essa função findByHeadOfIdAndAddedDateNotNullOrDurationNotNullcom os seguintes valores

headOfId: 0 scrollPosition: ScrollPosition.of(...) SolicitaçãoDePágina.of(0, 10)

ele me retorna aquela linha que está lá. Eu não espero isso, porque o que headOfIdestou passando é 0Le não 1000L.

Não consigo usar uma @Queryanotação, então recebo isso

Não foi possível criar uma consulta para o resumo público org.springframework.data.domain.Window org...jpa.repository.ItemRepository.findByHeadOfIdAndAddedDateNotNullOrDurationNotNull(long,org.springframework.data.domain.ScrollPosition,org.springframework.data.domain.Pageable); Motivo: Consultas de rolagem não são suportadas usando consultas baseadas em String

Existe uma solução para isso?

Eu tenho essa interface

interface Base {
    common: {
        foo: string,
    }
}

interface ExtendedOne extends Base {
    count: number,
}

interface ExtendedTwo extends Base {
    origin: string,
}

Agora, o que eu quero é, por meio da interfacedefinição de ExtendedOne, ExtendedTwoadicionar outra propriedade mais o tipo à commonpropriedade proveniente de Base.

Então digamos (pseudocódigo)

interface ExtendedOne extends Base {
    count: number,
    common: {
        ...Base,
        anotherProp: boolean,
    }
}

interface ExtendedTwo extends Base {
    origin: string,
    common: {
        ...Base,
        anotherProp: number,
    }
}

O prop adicionado sempre terá o mesmo nome (aqui anotherProp), mas o tipo será diferente.

Se necessário, a interface pode ser alterada para um tipo.

Eu tenho esse código

export interface CommonAnimalProps {
    name: string
  
}

export interface DogResponse extends CommonAnimalProps {

}

export interface CatResponse extends CommonAnimalProps {
    color: string,
}

export type AllAnimals = (DogResponse[] | CatResponse[])

export interface AllAnimalsProps {
    height: number | null,
    errorCodes: number[] | null,
    uuid?: string,
    [ANIMALS.dog]?: DogResponse[],
    [ANIMALS.cat]?: CatResponse[],
}

export enum ANIMALS {
    dog = 'dog',
    cat = 'cat'
}

export const transformCalculatedEmissionsResponse = (response: AllAnimalsProps): AllAnimals => {
    const result: AllAnimals = [];
    (Object.values(ANIMALS) as ANIMALS[]).map(animal => {
        const bars = response[animal]
        if (Array.isArray(bars)) {
            bars.map(bar => result.push(bar))
        }
    })
    return result
}

e falha nessa linha

bars.map(bar => result.push(bar))

Nenhum resultado O argumento do tipo 'DogResponse | CatResponse' não é atribuível ao parâmetro do tipo 'CatResponse'. A propriedade 'color' está ausente no tipo 'DogResponse', mas é necessária no tipo 'CatResponse'.

Por que e como resolver isso?

Aqui está um parque infantil

Eu tenho esta MappedSuperClass

@MappedSuperclass
abstract class BaseFoo(
    ...
) : FooItem {
    ...
}

sealed interface FooItem

Que é então usado assim

@Entity
@Table(name = "bar_1")
class Bar1(
    ...
) : BaseFoo(
    ...
) { ... }


@Entity
@Table(name = "bar_2")
class Bar2(
    ...
) : BaseFoo(
    ...
) { ... }


@Entity
@Table(name = "all_bar")
class AllBar(
    ...

    @OneToMany(mappedBy = "all_bar", fetch = FetchType.LAZY, cascade = [CascadeType.REMOVE])
    val bar1: List<Bar1>? = null,

    @OneToMany(mappedBy = "all_bar", fetch = FetchType.LAZY, cascade = [CascadeType.REMOVE])
    val bar2: List<Bar2>? = null,
) {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    var id: Long = 0

    val barItems: List<FooItem>
        get() = listOfNotNull(bar1, bar2).flatten()
}

Quero então adicionar uma declaração exaustiva quando

val bars = allBarRepository.findById(someId).getOrElse {...}
bars.barItems.forEach {
    when (it) {
        is Bar1 -> ...
        is Bar2 -> ...
    }

Mas o compilador diz

A expressão 'when' deve ser exaustiva, adicione o branch 'is BaseFoo' ou o branch 'else' necessários em vez disso

Não quero verificar BaseFoo, mas apenas Bar1e Bar2e se haverá mais Bar_<INT>para todas as outras Barras que serão adicionadas no futuro. Quero que o compilador reclame quando eu esquecer de adicionar qualquer uma delas Bar_<INT>aqui. Adicionar uma elseramificação ou verificar BaseFooisso não funcionará mais. Pensei que é para isso que sealed interfacespode ser usado?

Eu tenho essas interfaces

interface CommonAnimalProps {
    common: {
        size: number, 
        weight: number,
        origin: string,
    }
}

interface DogProps extends CommonAnimalProps {
    name: string
}

interface CatProps extends CommonAnimalProps {
    furious: boolean
}

interface BirdProps extends CommonAnimalProps {
    canFly: boolean
}

export enum AnimalType {
    dog = "dog",
    cat = "cat",
    bird = "bird",
}

export interface AnimalTypeToAnimalPropsMap {
    [AnimalType.dog]: (DogProps)[],
    [AnimalType.cat]: (CatProps)[],
    [AnimalType.bird]: (BirdProps)[]
}

export type AllAnimalValues<T> = T[keyof T]
export type AllAnimalTypesArray = AllAnimalValues<AnimalTypeToAnimalPropsMap>
export type AllAnimalTypes = AllAnimalValues<AnimalTypeToAnimalPropsMap>[0]
export type AllAnimalTypesArrayDiscriminating = AllAnimalTypes[]

Isso AllAnimalTypesArrayDiscriminatingresulta em uma matriz parecida com esta

const foo: AllAnimalTypesArrayDiscriminating = [
    {
        name: "Bello",
        common: {
            size: 10,
            weight: 25,
            origin: "Knowhwere"

        },
    },
    {
        furious: true,
        common: {
            size: 3,
            weight: 5,
            origin: "Anywhere"

        },
    },
    {
        canFly: false,
        common: {
            size: 39,
            weight: 50,
            origin: "Somewhere"

        },
    },    
]

É possível usar AllAnimalTypesArrayDiscriminatinge criar um novo tipo/interface a partir dele ( AllAnimalTypesArrayDiscriminatingModified), onde cada elemento na matriz resultante bartem outro prop ( color: string) adicionado para CommonAnimalPropsque o resultado fique assim

const bar: AllAnimalTypesArrayDiscriminatingModified = [
  {
    name: "Bello",
    common: {
      size: 10,
      weight: 25,
      origin: "Knowhwere",
      color: 'red',

    },
  },
  {
    furious: true,
    common: {
      size: 3,
      weight: 5,
      origin: "Anywhere",
      color: 'brown',

    }
  }, {
    canFly: false,
    common: {
      size: 39,
      weight: 50,
      origin: "Somewhere",
      color: 'white',

    },
  }
];

Observe que não posso modificar o original CommonAnimalPropspara adicionar colorcomo um parâmetro opcional. Também não posso editar DogProps, CatProps, BirdProps. Estou procurando uma maneira que uses AllAnimalTypesArrayDiscriminating(ou qualquer um dos outros tipos que não excluí) para adicionar esta propriedade. Existe uma maneira de fazer isso?

Estou executando a versão 15.4 (15F31d). Ontem instalei uma atualização, abri o XCode novamente e apareceu uma mensagem como "Simulador precisa de atualização". Cliquei em OK, nada aconteceu. Agora, todos os meus simuladores desapareceram e não consigo recuperá-los. Já reiniciei o XCode e também o meu computador.

Aqui, antes de instalar o atualizado, pude selecionar diferentes simuladores

É assim que fica quando clico em "Gerenciar destinos de execução...". Todos eles possuem a seleção "Mostrar destino de execução: Sempre"

No Product - Destinationmenu que selecionei Show all run destinations.

O que não entendo é que posso iniciar o App Simulador

Mas o XCode não reconhece nenhum simulador...

Quando conecto meu iPhone, ele não aparece aqui

mas eu posso ver isso aqui

Eu também tentei executá-lo na linha de comando

$ xcrun simctl list devices

que me deu

    iPhone Xs (6723AC4A-4B19-46F5-BAE5-6C3DF2BC253B) (Shutdown)
    iPhone SE (3rd generation) (CA9C9B3E-B542-412C-B845-71A0B7D9D797) (Booted)
    iPhone SE (3rd generation) (DB2FF536-D849-4786-B3BD-8FB7068F212A) (Shutdown)
    iPhone 15 (B039DEC7-D015-4313-A7D9-2CB2324E232B) (Shutdown)
    iPhone 15 Plus (797BBF51-A7A9-4F41-A532-424B775AB14D) (Shutdown)
    iPhone 15 Pro (36E9933C-D4FB-4818-B4EA-F3ADE9BC5AFF) (Shutdown)
    iPhone 15 Pro Max (4CDB180C-79F2-4827-B2AB-256F1812FE98) (Shutdown)
    iPad Air (5th generation) (AE3E77BB-137D-42EC-B2C0-2179320216F6) (Shutdown)
    iPad (10th generation) (8FD9CB57-CEBA-4570-B7F0-FDEFAAF20683) (Shutdown)
    iPad mini (6th generation) (0B6E1473-1864-49B0-BB91-4A2C4F692424) (Shutdown)
    iPad Pro (11-inch) (4th generation) (6B9E5069-A52A-4772-96D9-68FFCF496BEC) (Shutdown)
    iPad Pro (12.9-inch) (6th generation) (1E45FFF9-E844-4EFC-9938-59C80F8721D7) (Shutdown)

Então eu corro

$ yarn ios --udid "CA9C9B3E-B542-412C-B845-71A0B7D9D797"

Que voltou

error Failed to build iOS project. "xcodebuild" exited with error code '70'. To debug build logs further, consider building your app with Xcode.app, by opening 'Foo.xcworkspace'.
Command line invocation:
    /Applications/Xcode.app/Contents/Developer/usr/bin/xcodebuild -workspace Foo.xcworkspace -configuration Debug -scheme Foo -destination id=CA9C9B3E-B542-412C-B845-71A0B7D9D797

User defaults from command line:
    IDEPackageSupportUseBuiltinSCM = YES


2024-07-25 15:38:32.989 xcodebuild[2255:51186] Writing error result bundle to /var/folders/_j/5k_qtwqn5k39srgfty_40xmc0000gp/T/ResultBundle_2024-25-07_15-38-0032.xcresult
xcodebuild: error: Unable to find a destination matching the provided destination specifier:
        { id:CA9C9B3E-B542-412C-B845-71A0B7D9D797 }

    Ineligible destinations for the "Foo" scheme:
        { platform:iOS, id:dvtdevice-DVTiPhonePlaceholder-iphoneos:placeholder, name:Any iOS Device, error:iOS 17.5 is not installed. To use with Xcode, first download and install the platform }

error Command failed with exit code 1.

Por que não consigo mais executar meu aplicativo em um simulador? O meu iOS Deployment targetestá configurado para 13...

Não consigo encontrar um atalho que me leve ao arquivo anterior em que eu estava. Eu sei disso , no entanto, é muito refinado. Ele sempre salta para o local anterior do cursor. Se eu filmei muito o cursor em um arquivo, isso significa que tenho que percorrer todas essas posições antes de ir para o arquivo de onde vim. Quero poder ir diretamente para o arquivo de onde vim/estava anteriormente.

Existe um atalho?

Estou tentando usar nomes e valores de colunas dinâmicas em uma consulta no Spring Data JPA

interface CustomFooRepository {
    fun findByValueIgnoreCase(query: String, type: RequestType): List<Foo>
}

class CustomFooRepositoryImpl(
    @PersistenceContext private val entityManager: EntityManager
) : CustomFooRepository {

    override fun findByValueIgnoreCase(query: String, type: RequestType): List<Foo> {
        val column = when (type) {
            RequestType.first_name -> "first_name"
            RequestType.last_name -> "last_name"
            RequestType.email -> "email"
        }

        val sql = """
            SELECT 
                *,
                SIMILARITY(:column, :query) AS score
            FROM foo
            WHERE :column iLIKE %:query%
            ORDER BY score DESC NULLS LAST, :column
            LIMIT 20;
        """

        val constructedQuery = entityManager.createNativeQuery(sql, Foo::class.java)
        constructedQuery.setParameter("column", column)
        constructedQuery.setParameter("query", query)
        return constructedQuery.resultList as List<Foo>
    }
}


interface FooRepository : JpaRepository<Foo, Long>, CustomFooRepository

Mas isso me dá

org.springframework.dao.InvalidDataAccessResourceUsageException: Nenhum argumento para o parâmetro nomeado ':query%'

Por que?

Quero implementar a API scroll do Spring. Para que quando um usuário rola no Front End, novos dados sejam carregados a cada solicitação do Front end.

Tento limitar os resultados retornados pelo Spring e estou tentando de várias maneiras.

1. Solicitação de página

    // Service
    fun getOrders(customerId: Long): List<OrderDto> {
        val customer = customerRepository.findById(customerId).getOrElse { return emptyList() }
        val orders: WindowIterator<Order> = WindowIterator.of<Order> { position ->
            orderRepsitory.findAllByCustomerOrderByCreated(
                 customer, 
                 position as KeysetScrollPosition?,
                 PageRequest.of(0, 20)
            )
        }
            .startingAt(ScrollPosition.keyset())
        val ordersResult: MutableList<Orders> = ArrayList<Orders>()
        orders.forEachRemaining { ordersResult.add(it) }
        return ordersResult.map {
            OrderDto(...)
        }
    }


    // Order Respository
    interface OrderRepository : JpaRepository<Order, Long> {
    fun findAllByCustomerOrderByCreated(
        customer: Customer, 
        position: KeysetScrollPosition?,
        pageable: Pageable,
        ): Window<Order>
    }

Isso sempre retorna a tabela inteira.

2. Ajuste a consulta JPA

    // Order Respository
    interface OrderRepository : JpaRepository<Order, Long> {
    fun findFirst5ByCustomerOrderByCreated(
        customer: Customer, 
        position: KeysetScrollPosition?,
        ): Window<Order>
    }


    // call to repository in service
    orderRepsitory.findFirst5ByCustomerOrderByCreated(
        customer, 
        position as KeysetScrollPosition?
    )

Mesmo resultado, retorna a tabela inteira.

3. Usando Limite

    // Order Respository
    interface OrderRepository : JpaRepository<Order, Long> {
    fun findAllByCustomerOrderByCreated(
        customer: Customer, 
        limit: Limit,
        ): Window<Order>
    }

    // call to repository in service
    orderRepsitory.findAllByCustomerOrderByCreated(
        customer, 
        position as KeysetScrollPosition?,
         Limit.of(20)
    )

Mesmo resultado, retorna a tabela inteira.

Como limitar os resultados com a API Spring Scroll?

Eu tenho dois classesque são DTO's

class FooDto (
    val a: String,
    val b: Double,
)

class BarDto (
    val c: String,
    val d: String,
)

Agora, quero definir um terceiro AnotherDtoonde defino o tipo de propriedade como BartDtoou FooDto.

class AnotherDto (
    val e: FooDto || BarDto
)

Obviamente isso não funciona. Eu li sobre sealed classes, que ficaria assim

sealed class Menu{
   data class PIZZA(val name: String, val size:String, val quantity:Int):Menu()
   data class BURGER(val quantity:Int, val size:String): Menu()
   data class CHICKEN(val quantity:Int, val pieces:String):Menu()
}

No entanto, isso exige que eu defina todas as variáveis ​​(como name: Stringe quanitity: Int) novamente. Não é isso que eu quero, quero simplesmente reaproveitar o que foi definido anteriormente FooDtoe BarDtosem duplicar.

Então, é isso

sealed class FooBar{
   data class Foo(val a: String, val b: Double):FooBar()
   data class Bar(val c: String, val d: String): FooBar()
}

é meio inútil porque eu FooDtojá BarDtoescrevi e eles são usados ​​em outro lugar. Eu quero algo assim

sealed class FooBar{
   FooDto:FooBar()
   BarDto: FooBar()
}

O que obviamente não funciona.

Como reutilizo meus DTOs já escritos FooDtoe BarDtofaço um "tipo de união" que posso atribuir como tipo de dados a uma variável em Kotlin?