How to use io.yawp.repository.query

public Query(QueryBuilder<?> builder, boolean keysOnly) {
  this.builder = builder;
  this.keysOnly = keysOnly;
  this.r = builder.getRepository();
}

private void configureQuery(int batchSize, QueryBuilder<?> q) {
  if (cursor != null) {
    q.cursor(cursor);
  }
  q.limit(batchSize);
}

public List<T> list() {
  List<T> list = executeQueryList();
  sortList(list);
  return list;
}

private List<?> list(QueryBuilder<?> query) {
  List<?> objects;
  if (hasTransformer()) {
    objects = query.transform(getTransformerName()).list();
  } else {
    objects = query.list();
    applyGetFacade(objects);
  }
  return objects;
}

@Test
public void testBooleanCodition() {
  String q = "{where: {p: 'booleanValue', op: '=', v: true}}";
  QueryOptions options = QueryOptions.parse(q);
  assertSimpleCondition(options.getCondition(), "booleanValue", WhereOperator.EQUAL, true);
}

public IdRef<T> onlyId() throws NoResultException, MoreThanOneResultException {
  List<IdRef<T>> ids = ids();
  if (ids.size() == 0) {
    throw new NoResultException();
  }
  if (ids.size() > 1) {
    throw new MoreThanOneResultException();
  }
  return ids.get(0);
}

public QueryTransformer<F, T> where(String field, String operator, Object value) {
  query.where(field, operator, value);
  return this;
}

public QueryTransformer<F, T> cursor(String cursor) {
  query.cursor(cursor);
  return this;
}

public QueryBuilder<T> order(String property) {
  order(property, null);
  return this;
}

private T executeQueryOnly() throws MoreThanOneResultException {
  List<T> list = executeQuery();
  if (list.size() == 0) {
    throw new NoResultException();
  }
  if (list.size() == 1) {
    return list.get(0);
  }
  throw new MoreThanOneResultException();
}

@SuppressWarnings("unchecked")
private T getForcedResultFetch() {
  return (T) getForcedResult(QueryType.FETCH);
}

  @Override
  public int compare(Object o1, Object o2) {
    for (QueryOrder order : postOrders) {
      int compare = order.compare(o1, o2);
      if (compare == 0) {
        continue;
      }
      return compare;
    }
    return 0;
  }
});

public QueryTransformer<F, T> options(QueryOptions options) {
  query.options(options);
  return this;
}

public QueryBuilder<T> sort(String property) {
  sort(property, null);
  return this;
}

@Override
public <T> QueryBuilder<T> query(Class<T> clazz) {
  return QueryBuilder.q(clazz, this);
}

@Test
public void testWhereSimpleCondition() {
  String q = "{where: {p: 'longValue', op: '=', v: 1}}";
  QueryOptions options = QueryOptions.parse(q);
  assertSimpleCondition(options.getCondition(), "longValue", WhereOperator.EQUAL, 1l);
}

@Override
public void beforeQuery(QueryBuilder<HookedObject> q) {
  if (HookTest.LoggedUser.filter == null) {
    return;
  }
  q.where("stringValue", "=", HookTest.LoggedUser.filter);
}

@SuppressWarnings("unchecked")
private List<T> getForcedResultList() {
  return (List<T>) getForcedResult(QueryType.LIST);
}

  @Override
  public int compare(Object o1, Object o2) {
    for (QueryOrder order : preOrders) {
      int compare = order.compare(o1, o2);
      if (compare == 0) {
        continue;
      }
      return compare;
    }
    return 0;
  }
});

@SuppressWarnings("unchecked")
private List<IdRef<T>> getForcedResultIds() {
  return (List<IdRef<T>>) getForcedResult(QueryType.IDS);
}