Bind typed query parameters

use helix_db::dsl::prelude::*;

#[query]
fn find_users(tenant_id: String, limit: i64) -> ReadBatch {
    read_batch()
        .var_as(
            "users",
            g()
                .n_with_label("User")
                .where_(Predicate::eq("tenantId", tenant_id))
                .limit(limit)
                .value_map(Some(vec!["$id", "name", "tenantId"])),
        )
        .returning(["users"])
}

let request = find_users("acme".to_string(), 25);

const params = defineParams({
  tenant_id: param.string(),
  limit: param.i64(),
});

const query = readBatch()
  .varAs(
      "users",
      g()
      .nWithLabel("User")
      .where(Predicate.eq("tenantId", params.tenant_id))
      .limit(params.limit)
      .valueMap(["$id", "name", "tenantId"]),
  )
  .returning(["users"]);

const request = query.toQueryRequest(
  params,
  { tenant_id: "acme", limit: 25n },
  { queryName: "find_users" },
);

q := helix.ReadQuery("find_users")
tenant := q.ParamString("tenant_id", "acme")
limit := q.ParamI64("limit", 25)

request := q.
	VarAs(
		"users",
		helix.G().
			NWithLabel("User").
			Where(helix.PredEq("tenantId", tenant)).
			Limit(limit).
			ValueMap("$id", "name", "tenantId"),
	).
	Returning("users")

params = define_params({
    "tenant_id": param.string(),
    "limit": param.i64(),
})

query = (
    read_batch()
    .var_as(
        "users",
        g()
        .n_with_label("User")
        .where(Predicate.eq("tenantId", params.tenant_id))
        .limit(params.limit)
        .value_map(["$id", "name", "tenantId"]),
    )
    .returning(["users"])
)

request = query.to_query_request(
    params,
    {"tenant_id": "acme", "limit": 25},
    query_name="find_users",
)

{
  "request_type": "read",
  "query_name": "find_users",
  "query": {
    "read": {
      "entries": [{
        "query": {
          "name": "users",
          "root": {
            "value_map": {
              "input": {
                "limit": {
                  "input": {
                    "where": {
                      "input": {
                        "nodes_where": {
                          "predicate": {
                            "eq": {
                              "left": { "property": "$label" },
                              "right": { "constant": { "string": "User" } }
                            }
                          }
                        }
                      },
                      "predicate": {
                        "eq": {
                          "left": { "property": "tenantId" },
                          "right": { "param": "tenant_id" }
                        }
                      }
                    }
                  },
                  "count": { "expr": { "param": "limit" } }
                }
              },
              "properties": ["$id", "name", "tenantId"]
            }
          }
        }
      }],
      "returns": ["users"]
    }
  },
  "parameters": {
    "tenant_id": "acme",
    "limit": 25
  },
  "parameter_types": {
    "tenant_id": "string",
    "limit": "i64"
  }
}