Ash query with pagination makes calculation arguments fail

Ash Forum Ash Questions / Help
,
1

I have this query:

#Ash.Query<
  resource: Pacman.Markets.Entity,
  arguments: %{
    builder: %AshQueryBuilder{
      filters: [
        %AshQueryBuilder.Filter.In{
          id: "investment_style",
          field: :strategy,
          path: [],
          value: ["fix_and_flip", "buy_and_hold", "wholesaler"],
          enabled?: true,
          metadata: nil
        },
        %AshQueryBuilder.Filter.LessThan{
          id: "hide_institutions",
          field: :last_year_buy_records,
          path: [],
          value: 100,
          enabled?: true,
          metadata: nil
        },
        %AshQueryBuilder.Filter.Equal{
          id: "google_maps_geo_autocomplete",
          field: :geo_point,
          path: [],
          value: %{"lat" => 36.1626638, "lng" => -86.7816016},
          enabled?: true,
          metadata: nil
        },
        %AshQueryBuilder.Filter.Equal{
          id: "google_maps_address_autocomplete",
          field: :address,
          path: [],
          value: "Nashville, TN, USA",
          enabled?: true,
          metadata: nil
        },
        %AshQueryBuilder.Filter.Between{
          id: "from_now_last_days",
          field: :buy_date,
          path: [],
          value: [~D[2023-08-30], ~D[2024-02-28]],
          enabled?: true,
          metadata: "182"
        },
        %AshQueryBuilder.Filter.Equal{
          id: "distance_search",
          field: :distance_in_meters,
          path: [],
          value: Decimal.new("16093"),
          enabled?: true,
          metadata: "16093"
        }
      ],
      sorters: [
        %AshQueryBuilder.Sorter{
          id: "total_purchases",
          field: :purchases_total_amount,
          order: :desc
        },
        %AshQueryBuilder.Sorter{id: "score", field: :score, order: :desc}
      ]
    }
  },
  filter: #Ash.Filter<last_year_buy_records < 100 and fragment(
    {:raw, "st_dwithin("},
    {:expr, transactions.property_geography},
    {:raw, ", "},
    {:expr,
     %Geo.Point{
       coordinates: {-86.7816016, 36.1626638},
       srid: 4326,
       properties: %{}
     }},
    {:raw, "::geography, "},
    {:expr, 16093.0},
    {:raw, ")"}
  ) and fragment(
    {:raw, "("},
    {:expr, transactions.buy_date},
    {:raw, " between "},
    {:expr, ~D[2023-08-30]},
    {:raw, " and "},
    {:expr, ~D[2024-02-28]},
    {:raw, ")"}
  ) and transactions.strategy in [:fix_and_flip, :buy_and_hold, :wholesaler] and fragment(
    {:raw, "(case\n                  when "},
    {:expr, nil},
    {:raw, "::bigint is null and "},
    {:expr, nil},
    {:raw, "::bigint is not null then\n                    "},
    {:expr, transactions.property_bedrooms},
    {:raw, " <= "},
    {:expr, nil},
    {:raw, "::bigint\n                  when "},
    {:expr, nil},
    {:raw, "::bigint is not null and "},
    {:expr, nil},
    {:raw, "::bigint is null then\n                    "},
    {:expr, transactions.property_bedrooms},
    {:raw, " >= "},
    {:expr, nil},
    {:raw, "::bigint\n                  when "},
    {:expr, nil},
    {:raw, "::bigint is not null and "},
    {:expr, nil},
    {:raw, "::bigint is not null then\n                    "},
    {:expr, transactions.property_bedrooms},
    {:raw, "::bigint between "},
    {:expr, nil},
    {:raw, "::bigint and "},
    {:expr, nil},
    {:raw,
     "::bigint\n                  else\n                    true\n                  END)"}
  ) and fragment(
    {:raw, "(case\n                  when "},
    {:expr, nil},
    {:raw, "::bigint is null and "},
    {:expr, nil},
    {:raw, "::bigint is not null then\n                    "},
    {:expr, transactions.property_bathrooms},
    {:raw, " <= "},
    {:expr, nil},
    {:raw, "::bigint\n                  when "},
    {:expr, nil},
    {:raw, "::bigint is not null and "},
    {:expr, nil},
    {:raw, "::bigint is null then\n                    "},
    {:expr, transactions.property_bathrooms},
    {:raw, " >= "},
    {:expr, nil},
    {:raw, "::bigint\n                  when "},
    {:expr, nil},
    {:raw, "::bigint is not null and "},
    {:expr, nil},
    {:raw, "::bigint is not null then\n                    "},
    {:expr, transactions.property_bathrooms},
    {:raw, "::bigint between "},
    {:expr, nil},
    {:raw, "::bigint and "},
    {:expr, nil},
    {:raw,
     "::bigint\n                  else\n                    true\n                  END)"}
  ) and fragment(
    {:raw, "(case\n                  when "},
    {:expr, nil},
    {:raw, "::bigint is null and "},
    {:expr, nil},
    {:raw, "::bigint is not null then\n                    "},
    {:expr, transactions.property_living_area},
    {:raw, " <= "},
    {:expr, nil},
    {:raw, "::bigint\n                  when "},
    {:expr, nil},
    {:raw, "::bigint is not null and "},
    {:expr, nil},
    {:raw, "::bigint is null then\n                    "},
    {:expr, transactions.property_living_area},
    {:raw, " >= "},
    {:expr, nil},
    {:raw, "::bigint\n                  when "},
    {:expr, nil},
    {:raw, "::bigint is not null and "},
    {:expr, nil},
    {:raw, "::bigint is not null then\n                    "},
    {:expr, transactions.property_living_area},
    {:raw, " between "},
    {:expr, nil},
    {:raw, "::bigint and "},
    {:expr, nil},
    {:raw,
     "::bigint\n                  else\n                    true\n                  END)"}
  ) and fragment(
    {:raw, "(case\n                  when "},
    {:expr, nil},
    {:raw, "::numeric is null and "},
    {:expr, nil},
    {:raw, "::numeric is not null then\n                    "},
    {:expr, transactions.buy_price},
    {:raw, " <= "},
    {:expr, nil},
    {:raw, "::numeric\n                  when "},
    {:expr, nil},
    {:raw, "::numeric is not null and "},
    {:expr, nil},
    {:raw, "::numeric is null then\n                    "},
    {:expr, transactions.buy_price},
    {:raw, " >= "},
    {:expr, nil},
    {:raw, "::numeric\n                  when "},
    {:expr, nil},
    {:raw, "::numeric is not null and "},
    {:expr, nil},
    {:raw, "::numeric is not null then\n                    "},
    {:expr, transactions.buy_price},
    {:raw, " between "},
    {:expr, nil},
    {:raw, "::numeric and "},
    {:expr, nil},
    {:raw,
     "::numeric\n                  else\n                    true\n                  END)"}
  )>,
  sort: [
    {#Pacman.Markets.Entity.Calculations.PurchasesTotalAmount<[]> - %{builder: %AshQueryBuilder{filters: [%AshQueryBuilder.Filter.In{id: "investment_style", field: :strategy, path: [], value: ["fix_and_flip", "buy_and_hold", "wholesaler"], enabled?: true, metadata: nil}, %AshQueryBuilder.Filter.LessThan{id: "hide_institutions", field: :last_year_buy_records, path: [], value: 100, enabled?: true, metadata: nil}, %AshQueryBuilder.Filter.Equal{id: "google_maps_geo_autocomplete", field: :geo_point, path: [], value: %{"lat" => 36.1626638, "lng" => -86.7816016}, enabled?: true, metadata: nil}, %AshQueryBuilder.Filter.Equal{id: "google_maps_address_autocomplete", field: :address, path: [], value: "Nashville, TN, USA", enabled?: true, metadata: nil}, %AshQueryBuilder.Filter.Between{id: "from_now_last_days", field: :buy_date, path: [], value: [~D[2023-08-30], ~D[2024-02-28]], enabled?: true, metadata: "182"}, %AshQueryBuilder.Filter.Equal{id: "distance_search", field: :distance_in_meters, path: [], value: Decimal.new("16093"), enabled?: true, metadata: "16093"}], sorters: [%AshQueryBuilder.Sorter{id: "total_purchases", field: :purchases_total_amount, order: :desc}, %AshQueryBuilder.Sorter{id: "score", field: :score, order: :desc}]}},
     :desc}
  ],
  load: [skip_traces: [], registered_agent: []],
  calculations: %{
    purchases: #Pacman.Markets.Entity.Calculations.Purchases<[]> - %{builder: %AshQueryBuilder{filters: [%AshQueryBuilder.Filter.In{id: "investment_style", field: :strategy, path: [], value: ["fix_and_flip", "buy_and_hold", "wholesaler"], enabled?: true, metadata: nil}, %AshQueryBuilder.Filter.LessThan{id: "hide_institutions", field: :last_year_buy_records, path: [], value: 100, enabled?: true, metadata: nil}, %AshQueryBuilder.Filter.Equal{id: "google_maps_geo_autocomplete", field: :geo_point, path: [], value: %{"lat" => 36.1626638, "lng" => -86.7816016}, enabled?: true, metadata: nil}, %AshQueryBuilder.Filter.Equal{id: "google_maps_address_autocomplete", field: :address, path: [], value: "Nashville, TN, USA", enabled?: true, metadata: nil}, %AshQueryBuilder.Filter.Between{id: "from_now_last_days", field: :buy_date, path: [], value: [~D[2023-08-30], ~D[2024-02-28]], enabled?: true, metadata: "182"}, %AshQueryBuilder.Filter.Equal{id: "distance_search", field: :distance_in_meters, path: [], value: Decimal.new("16093"), enabled?: true, metadata: "16093"}], sorters: [%AshQueryBuilder.Sorter{id: "total_purchases", field: :purchases_total_amount, order: :desc}, %AshQueryBuilder.Sorter{id: "score", field: :score, order: :desc}]}},
    sales: #Pacman.Markets.Entity.Calculations.Sales<[]> - %{builder: %AshQueryBuilder{filters: [%AshQueryBuilder.Filter.In{id: "investment_style", field: :strategy, path: [], value: ["fix_and_flip", "buy_and_hold", "wholesaler"], enabled?: true, metadata: nil}, %AshQueryBuilder.Filter.LessThan{id: "hide_institutions", field: :last_year_buy_records, path: [], value: 100, enabled?: true, metadata: nil}, %AshQueryBuilder.Filter.Equal{id: "google_maps_geo_autocomplete", field: :geo_point, path: [], value: %{"lat" => 36.1626638, "lng" => -86.7816016}, enabled?: true, metadata: nil}, %AshQueryBuilder.Filter.Equal{id: "google_maps_address_autocomplete", field: :address, path: [], value: "Nashville, TN, USA", enabled?: true, metadata: nil}, %AshQueryBuilder.Filter.Between{id: "from_now_last_days", field: :buy_date, path: [], value: [~D[2023-08-30], ~D[2024-02-28]], enabled?: true, metadata: "182"}, %AshQueryBuilder.Filter.Equal{id: "distance_search", field: :distance_in_meters, path: [], value: Decimal.new("16093"), enabled?: true, metadata: "16093"}], sorters: [%AshQueryBuilder.Sorter{id: "total_purchases", field: :purchases_total_amount, order: :desc}, %AshQueryBuilder.Sorter{id: "score", field: :score, order: :desc}]}},
    sales_total_amount: #Pacman.Markets.Entity.Calculations.SalesTotalAmount<[]> - %{builder: %AshQueryBuilder{filters: [%AshQueryBuilder.Filter.In{id: "investment_style", field: :strategy, path: [], value: ["fix_and_flip", "buy_and_hold", "wholesaler"], enabled?: true, metadata: nil}, %AshQueryBuilder.Filter.LessThan{id: "hide_institutions", field: :last_year_buy_records, path: [], value: 100, enabled?: true, metadata: nil}, %AshQueryBuilder.Filter.Equal{id: "google_maps_geo_autocomplete", field: :geo_point, path: [], value: %{"lat" => 36.1626638, "lng" => -86.7816016}, enabled?: true, metadata: nil}, %AshQueryBuilder.Filter.Equal{id: "google_maps_address_autocomplete", field: :address, path: [], value: "Nashville, TN, USA", enabled?: true, metadata: nil}, %AshQueryBuilder.Filter.Between{id: "from_now_last_days", field: :buy_date, path: [], value: [~D[2023-08-30], ~D[2024-02-28]], enabled?: true, metadata: "182"}, %AshQueryBuilder.Filter.Equal{id: "distance_search", field: :distance_in_meters, path: [], value: Decimal.new("16093"), enabled?: true, metadata: "16093"}], sorters: [%AshQueryBuilder.Sorter{id: "total_purchases", field: :purchases_total_amount, order: :desc}, %AshQueryBuilder.Sorter{id: "score", field: :score, order: :desc}]}},
    purchases_total_amount: #Pacman.Markets.Entity.Calculations.PurchasesTotalAmount<[]> - %{builder: %AshQueryBuilder{filters: [%AshQueryBuilder.Filter.In{id: "investment_style", field: :strategy, path: [], value: ["fix_and_flip", "buy_and_hold", "wholesaler"], enabled?: true, metadata: nil}, %AshQueryBuilder.Filter.LessThan{id: "hide_institutions", field: :last_year_buy_records, path: [], value: 100, enabled?: true, metadata: nil}, %AshQueryBuilder.Filter.Equal{id: "google_maps_geo_autocomplete", field: :geo_point, path: [], value: %{"lat" => 36.1626638, "lng" => -86.7816016}, enabled?: true, metadata: nil}, %AshQueryBuilder.Filter.Equal{id: "google_maps_address_autocomplete", field: :address, path: [], value: "Nashville, TN, USA", enabled?: true, metadata: nil}, %AshQueryBuilder.Filter.Between{id: "from_now_last_days", field: :buy_date, path: [], value: [~D[2023-08-30], ~D[2024-02-28]], enabled?: true, metadata: "182"}, %AshQueryBuilder.Filter.Equal{id: "distance_search", field: :distance_in_meters, path: [], value: Decimal.new("16093"), enabled?: true, metadata: "16093"}], sorters: [%AshQueryBuilder.Sorter{id: "total_purchases", field: :purchases_total_amount, order: :desc}, %AshQueryBuilder.Sorter{id: "score", field: :score, order: :desc}]}},
    total_profit: #Pacman.Markets.Entity.Calculations.TotalProfit<[]> - %{builder: %AshQueryBuilder{filters: [%AshQueryBuilder.Filter.In{id: "investment_style", field: :strategy, path: [], value: ["fix_and_flip", "buy_and_hold", "wholesaler"], enabled?: true, metadata: nil}, %AshQueryBuilder.Filter.LessThan{id: "hide_institutions", field: :last_year_buy_records, path: [], value: 100, enabled?: true, metadata: nil}, %AshQueryBuilder.Filter.Equal{id: "google_maps_geo_autocomplete", field: :geo_point, path: [], value: %{"lat" => 36.1626638, "lng" => -86.7816016}, enabled?: true, metadata: nil}, %AshQueryBuilder.Filter.Equal{id: "google_maps_address_autocomplete", field: :address, path: [], value: "Nashville, TN, USA", enabled?: true, metadata: nil}, %AshQueryBuilder.Filter.Between{id: "from_now_last_days", field: :buy_date, path: [], value: [~D[2023-08-30], ~D[2024-02-28]], enabled?: true, metadata: "182"}, %AshQueryBuilder.Filter.Equal{id: "distance_search", field: :distance_in_meters, path: [], value: Decimal.new("16093"), enabled?: true, metadata: "16093"}], sorters: [%AshQueryBuilder.Sorter{id: "total_purchases", field: :purchases_total_amount, order: :desc}, %AshQueryBuilder.Sorter{id: "score", field: :score, order: :desc}]}}
  }
>

As you can see, this query loads some calculations that requires an argument to be passed to it.

When I run this query via the api read! function with these options: [page: [limit: 15]], the query will work just fine.

After that, if I want to get the next page, I run the read! function with the exact same query but with this options:

[
  page: [
    limit: 15,
    after: "g2wAAAACYgBRonBtAAAAJDAxOGQyODMwLWQ1MjEtN2RkMy1iYjY3LTE5Zjc5MzU0NTI2Mmo="
  ]
]

I get this error:

** (Ash.Error.Invalid) Input Invalid                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                              
* Invalid value provided for calculation argument builder in purchases_total_amount: : is required.                                                                                                                                                           
                                                                                                                                                                                                                                                              
nil                                                                                                                                                                                                                                                           
                                                                                                                                                                                                                                                              
    at filter                                                                                                                                                                                                                                                 
  (elixir 1.16.1) lib/process.ex:860: Process.info/2                                                                                                                                                                                                          
  (ash 2.19.9) lib/ash/error/exception.ex:59: Ash.Error.Query.InvalidCalculationArgument.exception/1                                                                                                                                                          
  (ash 2.19.9) lib/ash/query/query.ex:1597: anonymous fn/6 in Ash.Query.validate_calculation_arguments/3                                                                                                                                                      
  (elixir 1.16.1) lib/enum.ex:4842: Enumerable.List.reduce/3                                                                                                                                                                                                  
  (elixir 1.16.1) lib/enum.ex:2582: Enum.reduce_while/3                                                                                                                                                                                                       
  (ash 2.19.9) lib/ash/filter/filter.ex:2681: Ash.Filter.add_expression_part/3                                                                                                                                                                                
  (ash 2.19.9) lib/ash/filter/filter.ex:2335: anonymous fn/3 in Ash.Filter.parse_expression/2                                                                                                                                                                 
  (elixir 1.16.1) lib/enum.ex:4842: Enumerable.List.reduce/3                                                                                                                                                                                                  
    (elixir 1.16.1) lib/process.ex:860: Process.info/2                                                                                                                                                                                                        
    (ash 2.19.9) lib/ash/error/exception.ex:59: Ash.Error.Invalid.exception/1                                                                                                                                                                                 
    (ash 2.19.9) lib/ash/error/error.ex:600: Ash.Error.choose_error/2                                                                                                                                                                                         
    (ash 2.19.9) lib/ash/error/error.ex:260: Ash.Error.to_error_class/2                                                                                                                                                                                       
    (ash 2.19.9) lib/ash/actions/read/read.ex:278: Ash.Actions.Read.do_run/3                                                                                                                                                                                  
    (ash 2.19.9) lib/ash/actions/read/read.ex:49: anonymous fn/3 in Ash.Actions.Read.run/3                                                                                                                                                                    
    (ash 2.19.9) lib/ash/actions/read/read.ex:48: Ash.Actions.Read.run/3                                                                                                                                                                                      
    (ash 2.19.9) lib/ash/api/api.ex:2554: Ash.Api.read!/3                                                                                                                                                                                                     
Function: &Blibs.read!/2                                                                                                                                                                                                                                      
    Args: [#Ash.Query<resource: Pacman.Markets.Entity, arguments: %{builder: %AshQueryBuilder{filters: [%AshQueryBuilder.Filter.In{id: "investment_style", field: :strategy, path: [], value: ["fix_and_flip", "buy_and_hold", "wholesaler"], enabled?: true, 
metadata: nil}, %AshQueryBuilder.Filter.LessThan{id: "hide_institutions", field: :last_year_buy_records, path: [], value: 100, enabled?: true, metadata: nil}, %AshQueryBuilder.Filter.Equal{id: "google_maps_geo_autocomplete", field: :geo_point, path: [], 
value: %{"lat" => 36.1626638, "lng" => -86.7816016}, enabled?: true, metadata: nil}, %AshQueryBuilder.Filter.Equal{id: "google_maps_address_autocomplete", field: :address, path: [], value: "Nashville, TN, USA", enabled?: true, metadata: nil}, %AshQueryBu
ilder.Filter.Between{id: "from_now_last_days", field: :buy_date, path: [], value: [~D[2023-08-30], ~D[2024-02-28]], enabled?: true, metadata: "182"}, %AshQueryBuilder.Filter.Equal{id: "distance_search", field: :distance_in_meters, path: [], value: Decima
l.new("16093"), enabled?: true, metadata: "16093"}], sorters: [%AshQueryBuilder.Sorter{id: "total_purchases", field: :purchases_total_amount, order: :desc}, %AshQueryBuilder.Sorter{id: "score", field: :score, order: :desc}]}}, filter: #Ash.Filter<last_ye
ar_buy_records < 100 and fragment({:raw, "st_dwithin("}, {:expr, transactions.property_geography}, {:raw, ", "}, {:expr, %Geo.Point{coordinates: {-86.7816016, 36.1626638}, srid: 4326, properties: %{}}}, {:raw, "::geography, "}, {:expr, 16093.0}, {:raw, "
)"}) and fragment({:raw, "("}, {:expr, transactions.buy_date}, {:raw, " between "}, {:expr, ~D[2023-08-30]}, {:raw, " and "}, {:expr, ~D[2024-02-28]}, {:raw, ")"}) and transactions.strategy in [:buy_and_hold, :fix_and_flip, :wholesaler] and fragment({:ra
w, "(case\n                  when "}, {:expr, nil}, {:raw, "::bigint is null and "}, {:expr, nil}, {:raw, "::bigint is not null then\n                    "}, {:expr, transactions.property_bedrooms}, {:raw, " <= "}, {:expr, nil}, {:raw, "::bigint\n       
           when "}, {:expr, nil}, {:raw, "::bigint is not null and "}, {:expr, nil}, {:raw, "::bigint is null then\n                    "}, {:expr, transactions.property_bedrooms}, {:raw, " >= "}, {:expr, nil}, {:raw, "::bigint\n                  when "}
, {:expr, nil}, {:raw, "::bigint is not null and "}, {:expr, nil}, {:raw, "::bigint is not null then\n                    "}, {:expr, transactions.property_bedrooms}, {:raw, "::bigint between "}, {:expr, nil}, {:raw, "::bigint and "}, {:expr, nil}, {:raw
, "::bigint\n                  else\n                    true\n                  END)"}) and fragment({:raw, "(case\n                  when "}, {:expr, nil}, {:raw, "::bigint is null and "}, {:expr, nil}, {:raw, "::bigint is not null then\n              
      "}, {:expr, transactions.property_bathrooms}, {:raw, " <= "}, {:expr, nil}, {:raw, "::bigint\n                  when "}, {:expr, nil}, {:raw, "::bigint is not null and "}, {:expr, nil}, {:raw, "::bigint is null then\n                    "}, {:expr,
 transactions.property_bathrooms}, {:raw, " >= "}, {:expr, nil}, {:raw, "::bigint\n                  when "}, {:expr, nil}, {:raw, "::bigint is not null and "}, {:expr, nil}, {:raw, "::bigint is not null then\n                    "}, {:expr, transactions
.property_bathrooms}, {:raw, "::bigint between "}, {:expr, nil}, {:raw, "::bigint and "}, {:expr, nil}, {:raw, "::bigint\n                  else\n                    true\n                  END)"}) and fragment({:raw, "(case\n                  when "}, {
:expr, nil}, {:raw, "::bigint is null and "}, {:expr, nil}, {:raw, "::bigint is not null then\n                    "}, {:expr, transactions.property_living_area}, {:raw, " <= "}, {:expr, nil}, {:raw, "::bigint\n                  when "}, {:expr, nil}, {:
raw, "::bigint is not null and "}, {:expr, nil}, {:raw, "::bigint is null then\n                    "}, {:expr, transactions.property_living_area}, {:raw, " >= "}, {:expr, nil}, {:raw, "::bigint\n                  when "}, {:expr, nil}, {:raw, "::bigint 
is not null and "}, {:expr, nil}, {:raw, "::bigint is not null then\n                    "}, {:expr, transactions.property_living_area}, {:raw, " between "}, {:expr, nil}, {:raw, "::bigint and "}, {:expr, nil}, {:raw, "::bigint\n                  else\n 
                   true\n                  END)"}) and fragment({:raw, "(case\n                  when "}, {:expr, nil}, {:raw, "::numeric is null and "}, {:expr, nil}, {:raw, "::numeric is not null then\n                    "}, {:expr, transactions.buy_p
rice}, {:raw, " <= "}, {:expr, nil}, {:raw, "::numeric\n                  when "}, {:expr, nil}, {:raw, "::numeric is not null and "}, {:expr, nil}, {:raw, "::numeric is null then\n                    "}, {:expr, transactions.buy_price}, {:raw, " >= "}, 
{:expr, nil}, {:raw, "::numeric\n                  when "}, {:expr, nil}, {:raw, "::numeric is not null and "}, {:expr, nil}, {:raw, "::numeric is not null then\n                    "}, {:expr, transactions.buy_price}, {:raw, " between "}, {:expr, nil}, 
{:raw, "::numeric and "}, {:expr, nil}, {:raw, "::numeric\n                  else\n                    true\n                  END)"})>, sort: [{#Pacman.Markets.Entity.Calculations.PurchasesTotalAmount<[]> - %{builder: %AshQueryBuilder{filters: [%AshQuer
yBuilder.Filter.In{id: "investment_style", field: :strategy, path: [], value: ["fix_and_flip", "buy_and_hold", "wholesaler"], enabled?: true, metadata: nil}, %AshQueryBuilder.Filter.LessThan{id: "hide_institutions", field: :last_year_buy_records, path: [
], value: 100, enabled?: true, metadata: nil}, %AshQueryBuilder.Filter.Equal{id: "google_maps_geo_autocomplete", field: :geo_point, path: [], value: %{"lat" => 36.1626638, "lng" => -86.7816016}, enabled?: true, metadata: nil}, %AshQueryBuilder.Filter.Equ
al{id: "google_maps_address_autocomplete", field: :address, path: [], value: "Nashville, TN, USA", enabled?: true, metadata: nil}, %AshQueryBuilder.Filter.Between{id: "from_now_last_days", field: :buy_date, path: [], value: [~D[2023-08-30], ~D[2024-02-28
]], enabled?: true, metadata: "182"}, %AshQueryBuilder.Filter.Equal{id: "distance_search", field: :distance_in_meters, path: [], value: Decimal.new("16093"), enabled?: true, metadata: "16093"}], sorters: [%AshQueryBuilder.Sorter{id: "total_purchases", fi
eld: :purchases_total_amount, order: :desc}, %AshQueryBuilder.Sorter{id: "score", field: :score, order: :desc}]}}, :desc}], load: [skip_traces: [], registered_agent: []], calculations: %{sales_total_amount: #Pacman.Markets.Entity.Calculations.SalesTotalA
mount<[]> - %{b (truncated)

So it seems that the builder argument is not being passed to the purchases_total_amount calculation.

I’m using the latest Ash version (2.19.9).

Also, not sure if this helps, but this query works fine if I rollback to this commit e331e24c7becf9bb7eace83d65cf09c07f741c81.

1 Like
2

Looks like a bug, please open an issue on ash GitHub :slight_smile: i will address as soon as i get the chance.

3

Hi @zachdaniel. I created this issue Pagination (keyset) does not work when trying to sort by calculation with argument · Issue #917 · ash-project/ash · GitHub

Just to add to this topic. The error occurs when trying to sort a calculation that has an argument.

In the issue I show that I have a resource with a calculation like this:

  calculate :purchases_total_amount, :integer do
       calculation Calculations.PurchasesTotalAmount

       argument :builder, :map, allow_nil?: false
     end

When trying something like

query
     |> Ash.Query.load(purchases_total_amount: args)
     |> Ash.Query.sort({:purchases_total_amount, {:desc, args}})

Calling after with the cursor causes the bug.

On second “page”

page = Pacman.Markets.Entity.Api.summary(builder)
 |> Pacman.Markets.read!(page: [limit: 1])

cursor = List.last(page.results).__metadata__.keyset
page = query |> Pacman.Markets.read!(page: [limit: 1, after: cursor])
4

Thanks for raising an issue. It really helps us.

1 Like