@NoRepositoryBean
public interface BaseRepository<T, K> extends JpaRepository<T, K>, JpaSpecificationExecutor<T> {

}
@Repository
public interface ClientRepository extends BaseRepository<ClientEntity, UUID> {

}

  @Transactional
  public Page<ClientDto> findAllClients(SearchPageable<ClientRequest> serachPage) {
    return clientRepository.findAll(PageRequest.of(1, 5))
        .map(clientMapper::convertEntity);
    
    ClientSpecification clientSpecification = new ClientSpecification(serachPage);
    return clientRepository.findAll(clientSpecification, clientSpecification.getPageable())
        .map(clientMapper::convertEntity);
  }

org.springframework.data.mapping.PropertyReferenceException: No property string found for type ClientEntity!
	at org.springframework.data.mapping.PropertyPath.<init>(PropertyPath.java:90)
	at org.springframework.data.mapping.PropertyPath.create(PropertyPath.java:437)
	at org.springframework.data.mapping.PropertyPath.create(PropertyPath.java:413)
	at org.springframework.data.mapping.PropertyPath.lambda$from$0(PropertyPath.java:366)
	at java.base/java.util.concurrent.ConcurrentMap.computeIfAbsent(ConcurrentMap.java:330)

  datasource:
    hikari:
      connection-timeout: 600000
      minimum-idle: 2
      maximum-pool-size: 5
      idle-timeout: 3000000
      max-lifetime: 3000000
      auto-commit: true
      pool-name: MYSQL-DEMO-POOL
#      auto-commit: false
#      minimum-idle: 1
#      maximum-pool-size: 10
#      connection-test-query: SELECT 1
#      data-source-properties:
#        cacheServerConfiguration: true
#      pool-name: limit-management-db-cp
    driver-class-name: org.postgresql.Driver
  
  jpa:
    generate-ddl: false
    database-platform: org.hibernate.dialect.PostgreSQL10Dialect
#    hibernate:
#      ddl-auto: validate
    properties:
      hibernate:
        hbm2ddl.auto: update
        show_sql: true
        use_sql_comments: true
        format_sql: true
        type: trace
#        dialect: org.hibernate.dialect.PostgreSQLDialect
#        order_inserts: true
#        order_updates: true
#        batch_versioned_data: true
#        jdbc:
#          batch_size: 20
#          use_streams_for_binary: true
#    open-in-view: false

@Entity
@Table(name = "client")
@SQLDelete(sql = "UPDATE client SET deleted=true WHERE uid = ? AND version = ?")
@Getter
@Setter
@ToString
@Builder
@FieldNameConstants
@NoArgsConstructor
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class ClientEntity extends AuditableEntity {

  @Column(name = "reg_code")
  private String regCode;

  @Column(name = "non_resident_reg_code")
  private String nonResidentRegCode;

  @Enumerated(EnumType.STRING)
  @Column(name = "identity_doc_type")
  private IdentityDocumentType identityDocumentType;

  @Column(name = "identity_doc_series")
  private String identityDocumentSeries;

  @Column(name = "identity_doc_number")
  private String identityDocumentNumber;

  @Column(name = "full_name", nullable = false)
  private String fullName;

  @Column(name = "surname")
  private String surname;

  @Column(name = "name")
  private String name;

  @Column(name = "second_name")
  private String secondName;

  @Enumerated(EnumType.STRING)
  @Column(name = "status", nullable = false)
  private ClientStatus status;

  @ManyToMany(cascade = CascadeType.ALL)
  @JoinTable(
      name = "client_employee",
      joinColumns = {@JoinColumn(name = "client_uid")},
      inverseJoinColumns = {@JoinColumn(name = "employee_uid")}
  )
  @ToString.Exclude
  private Set<EmployeeEntity> employees = new HashSet<>();
}

@MappedSuperclass
@EntityListeners(AuditingEntityListener.class)
@Getter
@Setter
public abstract class AuditableEntity extends BaseEntity 
}

@MappedSuperclass
@FilterDef(
    name = DELETED_FILTER_NAME,
    parameters = @ParamDef(name = DELETED_FILTER_PARAM, type = "boolean")
)
@Filter(
    name = DELETED_FILTER_NAME,
    condition = "deleted = :isDeleted"
)
@Getter
@Setter
@FieldNameConstants
public abstract class BaseEntity implements Serializable {
}