42 replies

Nested aggregates

In my Product Data Management webapp I'm trying to build with Ash, I have the following resources with attributes and relatioships in

App.Api

App.Api

that, combined, construct/define an

Item

Item

.

*

Category

Category

: has a

:code

:code

attribute
*

Family

Family

belongs_to

belongs_to

a Category (and also has a

:name

:name

, etc.)
*

Variant

Variant

belongs_to

belongs_to

a Variant, has a

:code

:code

attribute

The idea is that an

Item

Item

belongs_to

belongs_to

a Category and a Variant, and has a calculated attribute (also called :code) resulting from concatenating the Category

:code

:code

and the Variant

:code

:code

.

This means that

Item

Item

:code

:code

calculation must "pull" Category's

:code

:code

through the Variant it belongs to, which belongs to a Family, which belongs to a Category.

Item

Item

's calculated

:code

:code

uniquely identifies a record.

I have tried the following in a cascade,

In

lib/app/resources/item.ex

lib/app/resources/item.ex

  aggregates do
    first :category_code, :variant, :category_code
  end

  aggregates do
    first :category_code, :variant, :category_code
  end

lib/app/resources/variant.ex

lib/app/resources/variant.ex

  aggregates do
    first :category_code, :family, :category_code
  end

  aggregates do
    first :category_code, :family, :category_code
  end

lib/app/resources/family.ex

lib/app/resources/family.ex

  aggregates do
    first :category_code, :category, :code
  end

  aggregates do
    first :category_code, :category, :code
  end

...hoping that

App.Api.Item |> App.Api.read!

App.Api.Item |> App.Api.read!

would return records on which I can

App.Api.load!(:code)

App.Api.load!(:code)

.

Instead:

** (CaseClauseError) no case clause matching: {:error, [%Ash.Error.Unknown.UnknownError{error: "Must provide field type for first", field: nil, changeset: nil, query: nil, error_context: ["Loading aggregate: :category_code for query: #Ash.Query<resource: App.Api.Variant>"], vars: [], path: [:aggregates], stacktrace: #Stacktrace<>, class: :unknown}]}

** (CaseClauseError) no case clause matching: {:error, [%Ash.Error.Unknown.UnknownError{error: "Must provide field type for first", field: nil, changeset: nil, query: nil, error_context: ["Loading aggregate: :category_code for query: #Ash.Query<resource: App.Api.Variant>"], vars: [], path: [:aggregates], stacktrace: #Stacktrace<>, class: :unknown}]}

What is the Ash-idiomatic way of achieving the goal of being able to access

Item

Item

:code

:code

Ash Framework•4y ago•

42 replies

waseigo

Nested aggregates

In my Product Data Management webapp I'm trying to build with Ash, I have the following resources with attributes and relatioships in

App.Api

App.Api

that, combined, construct/define an

Item

Item

.

*

Category

Category

: has a

:code

:code

attribute
*

Family

Family

belongs_to

belongs_to

a Category (and also has a

:name

:name

, etc.)
*

Variant

Variant

belongs_to

belongs_to

a Variant, has a

:code

:code

attribute

The idea is that an

Item

Item

belongs_to

belongs_to

a Category and a Variant, and has a calculated attribute (also called :code) resulting from concatenating the Category

:code

:code

and the Variant

:code

:code

.

This means that

Item

Item

:code

:code

calculation must "pull" Category's

:code

:code

through the Variant it belongs to, which belongs to a Family, which belongs to a Category.

Item

Item

's calculated

:code

:code

uniquely identifies a record.

I have tried the following in a cascade,

In

lib/app/resources/item.ex

lib/app/resources/item.ex

  aggregates do
    first :category_code, :variant, :category_code
  end

  aggregates do
    first :category_code, :variant, :category_code
  end

lib/app/resources/variant.ex

lib/app/resources/variant.ex

  aggregates do
    first :category_code, :family, :category_code
  end

  aggregates do
    first :category_code, :family, :category_code
  end

lib/app/resources/family.ex

lib/app/resources/family.ex

  aggregates do
    first :category_code, :category, :code
  end

  aggregates do
    first :category_code, :category, :code
  end

...hoping that

App.Api.Item |> App.Api.read!

App.Api.Item |> App.Api.read!

would return records on which I can

App.Api.load!(:code)

App.Api.load!(:code)

.

Instead:

** (CaseClauseError) no case clause matching: {:error, [%Ash.Error.Unknown.UnknownError{error: "Must provide field type for first", field: nil, changeset: nil, query: nil, error_context: ["Loading aggregate: :category_code for query: #Ash.Query<resource: App.Api.Variant>"], vars: [], path: [:aggregates], stacktrace: #Stacktrace<>, class: :unknown}]}

** (CaseClauseError) no case clause matching: {:error, [%Ash.Error.Unknown.UnknownError{error: "Must provide field type for first", field: nil, changeset: nil, query: nil, error_context: ["Loading aggregate: :category_code for query: #Ash.Query<resource: App.Api.Variant>"], vars: [], path: [:aggregates], stacktrace: #Stacktrace<>, class: :unknown}]}

What is the Ash-idiomatic way of achieving the goal of being able to access

Item

Item

:code

:code

Nested aggregates

Nested aggregates

Similar Threads

Similar Threads

Similar Threads