documentation/2.0-CHANGELOG.md
All notable changes to this project will be documented in this file. See Conventional Commits for commit guidelines.
<!-- changelog -->add less_than, greater_than constraints to float, decimal (#936)
allow providing descriptions to Ash.Type.Enum values (#940)
convert %{__struct__: T} into %T{} (#947)
corrections for reload/reload! (#942)
show that Policy.Check.strict_check can return an error tuple (#945)
remove unnecessary function
fully expand calculation and aggregate references for applying authorization
batch_change/3 is never called for updates (#938)
bulk updates for streams ignore :batch_size
don't double-encode vector data (#934)
update set/get/update_context function specs to use maps (#935)
support load option for create/update/destroy (#946)
restore old behavior of leveraging in memory values for calculations
simplify inspect for aggregates
add matches built-in policy check (#937)
ensure calculation context is set on aggregate contents
set source_attribute from join_relationship in many_to_many (#932)
use proper logic for atomic present validations
Set tenant correctly when reading many_to_many relationship. (#928)
properly match no_rollback error
load with right module in get_rewrites of Ash.Type.Struct (#927)
ensure that calculation dependency loader combines selects
properly handle raised errors from async calculations
ensure depended on attributes are selected in calculations
properly merge related selects when merging loads
cast atomic reference types, makes life easier for data layers
use wrap_list for where in changes.change (#926)
don't require Mix to compile an Ash resource
typespec for action policy check supports list of action names (#924)
ensure that message is honored in atomic validations
don't require actor when constructing aggregate query
store casted values even if they are nil
Ash.Reactor: Backport improvements from 3.0 branch.
Ash.Reactor: Add a Reactor extension that makes working with resources easy. (#683)
Add Ash.Reactor with create support.
correct atomic implementation of present validation
track keys that are set to nil in changesets, for use in atomic upgrade
properly cast atomic constraints for integer
more fixes for atomic length validations
fix atomic error for string length type validation
Mimic copying Ash.Notifier seems to break the compiler for some reason.
do not perform atomic upgrade on destroy actions
Make undo actions for update and destroy actions more explicit. (#920)
Ash.Reactor: Make undo actions for update and destroy more explicit.
rename get to read_one in Ash.Reactor
Add Ash.Reactor update support.
Add Ash.Reactor destroy support.
Ash.Reactor: Support for transactional handling of notifications.
Ash.Reactor: Add read and get steps.
Ash.Reactor: add support for generic actions.
Add undo capability to create step.
transaction and undo working.
Automatically thread Ash tracers through Reactor.
Ash.Reactor: Add undo to generic actions.
Type.new in expr expansionproperly scope expanded calculations
properly scope expanded calculations
properly add aggregate authorization everywhere
ensure calculation arguments are not ignored when parsing filters
properly authorize aggregates
bad reference in atomic validations
prevent leakage of stale async_limiter's pid (#916)
ensure that policies are applied to aggregates referenced in calculations
ensure records are returned from bulk actions in atomic upgrades
handle small logic error in notification sending for bulk actions
ensure actor context is set in filter
properly handle limit/offset for aggregates
don't use Aggregate.new for builtin aggregates
merge root query into aggregate queries, don't apply both
properly catch errors in atomic changeset casting
use Ash.Changeset.set_context on changesets
properly fail early on missing actor in policies
handle :continue case in authorizer
validations run regardless of if the relevant fields are changing
honor soft destroys for atomic bulk destroys
properly set context on query and changeset
pass correct options into Api.stream! for bulk_destroy
check attributes after arguments for present?
correct for_read calls in update and destroy actions (#907)
run_flow's recursive DSL tagnot_found_error? in read_onepass tenant to context in custom changes
Ash.Context.to_opts now checks for a tenant
allow using custom delimiters for pubsub topics
support functions in parse predicates (#874)
support returning streams from mod calc (#864)
remove unneeded code for calculations in a filter (#904)
restore not_found_error? behavior in Ash.Flow
handle cases where no primary keys are present better
ensure that filters are parsed from policy authorizer ahead of time
check if query is a query before calling .__validated_for_action__
properly authorize actions in flow
handle warning about incompatible types (#892)
properly refer to attributes in changing_attributes/1
remove unneeded code for calculations in a filter (#891)
evaluate templates to unknown at ref
handle atomic_ref templates and changing_attributes/1
replace refs for relationships use correct action (#888)
handle not found case in destroy (#890)
handle not found case in destroy
add case where authoriztion did not change query
properly map sort input and non-input refs in keyset filters
properly match on invalid query from before_action
ensure proper context set on atomic upgrade
fix nil ++ list error in bulk destroy
ensure we retain the sort order of embedded resources
retain sort on inputs on casting embedded inputs
properly get rewrites for embedded types
ensure after_transaction hooks are always run
handle records in Ash.destroy and Ash.update
pre-template change/validation option in bulk update/destroy
fix query match error in bulk destroy/update
don't consider primary key matches with nil values
continue cleanup in ManagedRelationshipHelpers (#873)
fix pattern match error on certain policy conditions
use primary key for lateral join source in ets
set right accessing_from name in many to many managed create (#868)
set_tenant on fully atomic changesets
handle api.can case in authorize_changeset
properly bypass authorization in atomic update switch-over
properly set action_type on atomic changesets
extract relationship filters from pre-authorization query
retain metadata on updates, atomic and otherwise
properly load expression -> runtime calculation deps
ignore input? when considering refs equal in filter subset checking
change names of code interface methods for calculations (#863)
properly mark manually created input refs with input?: true
clean vars should handle map vars
properly merge union loads
support expression calculations referencing runtime calculations
set default access type properly
properly handle the case where all valid scenarios are pruned
properly prevent the atomic handling of manual update actions
fix passing extra opts to stream
properly check if data layer can update_query
Ash.Type.Float to support min/max constraints(#856)
add calculations before distinct is applied in data layer query
properly set index on embedded type array errors
use correct option for relationship in atomic relate_actor (#855)
only count resources the actor is allowed to see (#853)
only count resources the actor is allowed to see
deselect known forbidden fields after query authorization is complete
soft? in destroy action options is a boolean, not an atom (#851)
load fails because of empty list instead of query (#847)
don't attempt to derive destination_attribute_on_join_resource
join_relationship in many to many can make through optional (#846)
make sure query has action (#844)
pass in actor to api.can call (#843)
pass in actor to api.can call
do not check primary key fields in filter (#839)
add page opts to context again (#838)
return errors with query from read action
properly set defaults on upsert in mnesia
don't load through attributes twice, but also don't miss any
handle errors properly from invalid loads
handle data layer calculations for missing records
only load through calculations in the correct order
properly detect cyclic dependencies in calculation runner
properly annotate in-query calculations as complete for dependency calculation
fix present? and load_through bugs
don't require pagination in incorrect cases
get tests passing for bulk creates again
handle stale update/destroys
support authorize_query_with for bulk updates/destroys
support authorize_changeset_with for bulk updates/destroys
don't authorize query on synthesized atomic update/destroys
show field name in NotLoaded inspect
implement requires_original_data? for Ash.Notifier.PubSub
support policies requiring original data
change atomicity requirements when datalayers don't support it
add on_match: :update_join to manage_relationship (#875)
don't call telemetry when compiling
various policy behavior cleanups
add join_keys option to manage_relationship (#866)
don't run check in cases that require strict checks
atomic_batches behavior for bulk destroys
allow strategy selection for bulk actions
change nested field filtering to be done with at_path
support referencing non-array embeds in input filters
bulk update in batches if not given a query
update action should respect load and select
introduce require_atomic?, which defaults to false in 2.0, true in 3.0
better support around the mixing of atomic and non atomic changes/validations
more atomic implementations
support loading and selecting in bulk operations
use atomic create actions where possible
always define merge_load/4
derive source_attribute_on_join_resource for many to many
atomic implementation for relate_actor
include a message along with the non-atomic signifier
support transactions on bulk destroys
support transactions in bulk updates
count_nils/1 function
present/absent atomic implementation
add atomic_ref/1 template helper
Change typespec of tenant from String.t() to term() (#845)
handle pkey-less resources when attaching fields
set lazy defaults when applying changeset attributes
add prepend?: true option to add_change
optimize embedded resource creation
rewrite read actions to not use Ash.Engine (#836)
:self as an option when requesting a relative page from a given page (#833)add all_tenants? option to identities
support Ash.CiString in string_join (#832)
Add code interface support in Info and Builder. (#828)
authorize each related join using join_filters
fix runtime filter parsing & make last arg optional
undo incorrect behaviour in runtime evaluation
fix typespecs and cleanup Ash.Resource.Builder (#827)
join_filters in aggregatesrelate_actor with :many cardinality relationshipsonly put keywords to be interpolated in message in error vars (#821)
only put keywords to be interpolated in message in error vars
ignore empty relationship paths when authorizing relationships
properly build query from opts in aggregates
append new entities in Ash.Resource.Builder
simplify aggregate loading, remove Ash.Engine from it
add atomic implementation for builtin increment change
simplify related path authorization, use same tool as aggregates now use
Ash.Engineatomic validation implementations for most validations
support type operator overloading
add some atomic implementations
support :no_rollback and return_query/2 callback
add a return_query/2 callback for data layers
ensure __source__ is set on nested embedded attributes
don't include unknown authorize? value in changesets
support {:error, :no_rollback, error} from data layer callbacks
always update the join relationship
use new api option in Ash.Query.for_read/4
support using the new api option in actions
accept api option in Ash.Changeset.for_* functions
update Ash interface for working with new style resources
better formatting of nested expressions
helpful errors when misusing . in expressions
properly move maps & lists to expression paths
set tenant when running authorization queries
simplify used aggregate detection
add lazy/1 to expressions
support providing an input key in predicate maps
support streaming without keyset pagination
add callbacks for bulk actions on manual actions
base case iterative bulk destroy implemented
add iterative, streaming implementation for bulk updates
test ASH_THREE subprojects
empty milliseconds for utc datetime must have precision 6
ensure actor & authorize? contexts are set even if not provided
ignore load/limit/offset in aggregate queries, instead of raising
properly set changed? for all changesets
honor tenant option on aggregates
pass proper context into manual actions, remove unnecessary changeset code
ensure actions always raise an error class
detect impending manage_relationship calls when checking attribute presence
add stacktrace context to errors better
support tenancy on manual actions
lay the groundwork for fully atomic actions
rewrite creates to not use Ash.Engine
remove Ash.Engine from update/destroy actions
Ash.Type.Union.prepare_change_arrayadd Ash.Error.from_json/2
accept expressions in Ash.Query.calculate
don't create invalid datetimes when scrubbing microseconds
prepare change with nil old value on union type change
properly prepare union value changes when old & new are union structs
fix dump_to_embedded_array
test failures and credo issue
additional atomic callbacks
add warn_on_transaction_hooks?: false config
accept an action input in Ash.Error.to_ash_error/3
include tenant in change context
nil values in struct type callbacksdon't apply default limit unless pagination is required
properly handle union changes for lists of embeds
honor default_limit option in pagination
embed_nil_values? for trimming down stored embedsadd back in builtin_predicate_operators/0
various runtime expression evaluation fixes
honor read action for Api.get calls.
various fixes to calculation expansion and execution
forbid using resources as types
add composite_type/2 and composite_type/3
composite?/1 and composite_types/1 to Ash.Typeproperly resolve nested calculation dependencies
don't apply sort on manage relationship lookup
don't apply filter on manage relationship lookup if it has a parent expr
change_attribute failing on a union attribute (#778)
convert upsert fields before passing to data layer (#777)
sort and filter to synonymous_relationship checksproperly set actor context on calc expressions in ets data layer
properly pass authorize? option when loading aggregates
properly associate lateral join records with no_attributes? true
set aggregate context as well as calculation context in filters
set actor when computing aggregates that reference calculations
dialyzer issues on sort
properly return constraints in aggregate get_type
properly include relationship name message when relationship cannot be found (#770)
properly thread constraints through aggregates
remove destroyed or unrelated data from the relationship (#767)
properly strip extra record requested to detect more? pages.
don't attempt to key a struct
authorize?: false option in generic actionsensure item constraints are passed to array casting
handle non-list values in Ash.Actions.Sort.process/4
optimize and make Ash.Type more consistent
fix typespec for include_source/2
don't reorder global validations/changes
use latest spark, and new persisters callback
properly validate belongs_to relationships
remove invalid usages of unsafe_change_attribute/3
handle builtin types in unions (#752)
Change heading levels in generated livebook to have only one H1 (#747)
code gen interfaces check type first argument (#749)
properly support get in Ash
add back in accidentally removed transformer
properly determine resource from Ash.get!/2
cast functional default values
temporarily omit overzealous validation
properly honor max_concurrency option
support tenant option in api.can
properly use constraints when casting expression values
don't re-case constraints in the type function
add Ash.Test.assert_has_error and Ash.Test.refute_has_error
support to_error_class taking changeset/query/input
add "filename" parameter to the livebook generator. (#746)
support an api option to use Ash.Resource (#715)
support an api option to use Ash.Resource
add functions to Ash for resources w/ configured apis
default code_interface.define_for to resource's ash api
cast_input for default values at compile time
optimize bulk creates where results are not returned
rewrite bulk creates, optimize changeset functions (#744)
better storage_type handling, undo function change
init callbackhonor max_concurrency option
handle generic actions in list_arguments_and_attributes
fix type casting for embedded resources
ensure after action hooks are run on bulk creates
return records from batches if items have after action hooks
don't transform errors to changesets when rolling back in with_hooks
undo previous changes where transactional actions might not roll back
undo regression where errors weren't wrapped in a changeset
provide full constraints when determining Ash.Type.NewType storage types
go back to original default timestamp behavior
various optimizations and compile time caching
set default many to many options (#737)
various performance improvements
various optimizations for bulk create actions
support max_concurrency option on bulk creates
better error message on missing identities
better error message on invalid data passed to YourApi.load
better handling of nested errors in transactions
move misplaced file and fix typespecs for Ash.DataLayer.Ets.Info
properly set invalid_keys on action inputs
properly validate required arguments for generic actions
ci_stringauthorize? option for calls to aggregatefalse values properly when passed to flowssupport to-one reference paths in calculations
add Ash.Sort.expr_sort. In 3.0 sort should be a macro
properly rollback transactions on returned errors in generic actions
generate keysets immediately after read action
prepare_change_array on embedded types needs to handle nil
handle_change_array on embedded types needs to honor nil
cast_input/2 on NewTypedon't use || when fetching arguments because false || nil is nil
handle exceptions in generic actions
fix types for min/max constraints in Type.Float (#718)
lower compile time dependencies
raise cleaner error on missing action in bulk creates
allow for ref to contain nested templates
Ash.Error.to_ash_error/3unions, only load through types when loadable
handle empty list loads
properly perform field authorization on loaded through types
usage of get_by with belongs_to attribute (#712)
static checks with conditions could be overly or insufficiently restrictive
set field policy opts on field policy conditions
move Resource.Transformers.BelongsToSourceField into entity (#709)
context option to bulk_createdon't authorize on identity usage validations
handle empty batches in bulk create
update stream_data dependency, as we use the latest version
expose max/min constraints on Ash.Type.Float
rework utc_datetime to datetime
explicitly validate manual action return types
deprecate old school manual actions
better UX around nimble options errors
remove old, now-deprecated config
add Ash.Query.around_transaction/2
:wrap_list usage for topic in PubSub, needs recursion (#702)more usages of :wrap_list type (#700)
add missing usage of :default_belongs_to_type (#699)
sequence generator utilityproperly wrap [tracer] in Ash.Flow
use :wrap_list type where appropriate (#698)
get_by option can accept a single atom (#697)
properly handle nil values in embedded resources
ensure that can always returns an error when asked
get type for manual action at compile time
make storage_type overridable by new_types
support map_with_tag storage mode for Ash.Union.
if no authorizers are set, anyone can do anything
explicit error on after_action hook mismatch
recommit the dsl cheatsheets, and update ash-ci
add allow_nil? to generic actions, defaults to false
properly handle bubbled up exceptions from type casting
typo in new tracer setting logic
properly expose nested errors on unions
set_handled_error/3 for when errors are returnedsupport trace_type?/2 in tracers
support stacktraces in set_error
support multiple tracers, instead of just one
fix formatting for policies with conditions
policy mermaid chart fix forbid_unless behavior
negateash.reset and ash.tear_downfix no such action error on create changesets
remove policy documentation due to compile time links
show policy conditions, and fix final destination of last policy condition
include path in unique path for anonymous aggregates
show policy mermaid chart in moduledocs
add mix ash.generate_policy_chart
give anonymous aggregates constant names
sort operator names in keyset (#684)
action.update_default -> field.update_default typo
ensure that errors/records return the proper value in bulk creates
properly optimized nested get_path calls
simplify and fix duplicate detection in embedded resources
better handling of runtime maps & lists
properly handle as option for calculations in calculation dependencies
add Ash.Context.to_opts/1-2
add topic docs for atomics
implement atomics, expression-based changes (#682)
hide __order__ and __lateral_join_source__ on records
init validations at runtime not compile time
Ash.Filter: Don't overly constrain related references. (#678)
handle nil constraints in cast_input
properly handle in-line maps in exprs
don't cast notloaded/forbidden values at runtime
add required errors for missing read arguments
don't evaluate unknown types in basic operators
support in-line aggregates
Set api field for ActionInput when running action (#676)
make resource's DSL attributes section patchable (#675)
validate all actions and accept/reject fields at once. (#674)
Enum types only have storage_type/0 still
inspecting a query now only shows arguments explicitly set
don't set attributes or arguments to invalid values
storage_type/0 -> storage_type/1
Ash.Resource.Calculation: set struct defaults. (#673)
track invalid keys, don't add required errors for them
properly set path into error instead of on error messages
expose union errors with path when tag is set
find all installed extensions by default
handle atomic/string union type identifiers better
handle empty field policy lists better internally
add initial implementation of new mix tasks
add plural_name
don't optimized in/== predicates across incorrect boolean expressions
various fixes with runtime evaluation of aggregates
handle mnesia transaction errors properly
fix badly formatted error message
better error message in validate_related_resource_inclusion
add from_many? option to has_one
initialize change opts in bulk actions
handle changeset errors in mnesia transactions
fix builder for action preparations
validate resourcesin apis
added round/1 and round/2 to expressions
add new/1 to all ash errors, because its nicer
allow for parent/1 expressions to be resolved "later"
support parent/1 in relationships
enrich mnesdia data layer
validate arg (#662)
validate argument inequality
validate argument in
try to cast_stored expression calculation results
read argument value in ArgumentEquals validation (#664)
support distinct_sort in Query.build/2
inspect distinct_sort
Keyword.fetch on keywords, fix test name
allow the query & related fields to be read before authorization status is complete
support distinct_sort
use Comp.equal? for actor_attribute_equals check
support distincting on calculations
support distinct in ets data layer for testing
- unary operatoradd ForbiddenField exception
warn on api missing from config
support resources directly in API modules
compile time warning on resources not detected in any apis
exists type aggregateat/2 functionincorrect error for casting binary UUID (#653)
fix and improve policy breakdown logs
incorrect typespec for bulk_create/5. (#646)
add string_split expression
add field_policy_bypass
optimize field selection/loading when possible
deselect fields we know statically are not visible
handle_change/3 and prepare_change/3 to Ash.Type.Union (#642)properly detect selected attributes for changeset field policies
run before_action after authorization
Negate validation (#636)return accumulator to correct state after altering exists
typo in at_most validation message (#640)
load after all hooks have completed
don't allow is_nil as an expression operator
proper source field loading on related data
reselect all selected attributes on action loading
don't deselect fields on loading for changesets
field_policiesfix field policy expressions
handle various inconsistencies in runtime expression runner
fix loading w/ only nil values
add verifier for identity fields. (#626)
adds verifier for identity fields.
check paginability before streaming
properly set notification_data from loaded record
properly handle lazy loaded many to many relationships
remove duplicate doc for authorize? in Query.for_read_opts (#623)
set notification data with loaded result
honor not_found_error?: true opt in code interface get actions (#620)
typo on keyset refactor
api.can (#617)can_load?/1 -> can_load?/2
handle new load calculations in nested loading? checks
don't load nil values for runtime types
properly set upsert_keys on bulk upserts
continue refactor in code interface (#611)
honor query limit when streaming
refactor out some repetition in code interface (#609)
pass empty select statement when loading on changesets
fixes for loading through attributes
drop proper opts keys when calling api in code interface (#608)
various fixes to data loading
properly set tenant on nested calculation loads
properly set calc_name to resource calculation name on aliased calc loads
check correct calculation dependency for relationship
don't use to_string on the calculation names
don't need to check current aggs/calcs in filters anymore
set query tenant on calc dep loads
copy tenant to step on flow build (#603)
ensure add_tenant/1 checks the correctkey (#601)
optimize LoadRelationship calculation
Ash.Query.accessing/2 to get a list of fields being accessed
building LoadAttribute and LoadRelationship calculations
warn on invalid/impossible policies
support loading through types
properly set tenant from initial data
properly chain batch to each change in bulk creates
properly handle failed bulk creates with no errors
nils in memory the same way sql would havealso do not autogenerate values for optional fields that have a generator (#599)
rename few error files to match module names (#597)
changeset.loadOnly create values for attributes that did not get a generator (#595)
remove field name from string length error message (#594)
remove field name from string length error message
remove old unused Error.Changes.UnknownError
do not capitalize ash error messages
change error kind code for Ash.Error.Forbidden.Policy
as inputhandle pre-hydrated predicates in expressions
handle nil errors on bulk creates
add :forbidden to error_class, lowercase code for Forbidden (#589)
proper required value validations in bulk creates
don't use error count in place of errors
loading?/2 smarterproperly manage relationships on bulk creates
validations could undo certain changeset changes in bulk creates
properly upsert on non batchable rows
return_errors? optionproperly wrap errored changesets in bulk creates
don't notify unless notify?: true in bulk creates
properly wrap errored changesets in {:error in bulk creates
Exception.exception? for Kernel.is_exception (#584)accidental variable shadowing in calculation loading.
add missing batch_size opt for bulk_create (#581)
{:data_layer, *} for custom locksget_and_lock/1 builtin change:map as storage type for MapAsh.Type.Module: Add :module type. (#578)
handle ci strings in cast_stored
better default overflow logic
custom stale record error
changeset.filters:mapfix dialyzer
proper return value for synthesized bulk creates
assorted bulk create fixes
set upsert context from action on create changesets
handle invalid input in basic actions
bulk create improvements, docs
finishing initial touches on bulk actions
bulk create actions
initial support for basic actions
better messages for missed notifications
retain stacktraces from task errors
attribute_in/2 builtin validationmore typespec fixes
support lock option on read
data layer can? might get a dsl, not a resource
Api.stream!/1set flow argument defaults
handle join relationship in different api
don't warn on being managed from attribute changing
don't initially require attributes for belongs to relationships being managed
simple equality filter should not traverse ors
introduce basic locking
include resource validations by default
validate explicit api configurations, with good error messages
fields/1 and public_fields/1 to Ash.Resource.Info (#569)don't optimize across or boundaries
handle calculation deps w/ multiple nested relationship paths
only do tenant things in ETS if strategy is :context
add the spark function version of calculations
proper error message on invalid inline function calculation
Add tenant attribute to identity attributes on upserts (#565)
Add upserts option to flow's create step (#566)
Change storage type of Ash.Type.Term to :binary (#561)
automatically gather up notifications
don't require values if a changeset result has been set
properly return errors on invalid calculation arguments
user unpaginated_read for read_one
handle strings better in refs
consider strings in ref
add build_action_metadata to resource builder
add Ash.merge_context/1 and Ash.update_context/1
add constraints to maps (#556)
various ash flow return value fixes
Fix set_new_attribute by adding missing option to set_attribute (#553)
show context on all errors
include error context in top level of errors
validate returnable steps in flow returns
update touched_resources logic
Add :field option to relate_actor change (#546)
properly handle nested calculation selects
fix typespecs and not_found_error? code interface option
typespec support Expr.t() in calculation builder
remove bad default for struct constraint
use values when already loading aggregates
thread context through when loading data
update spark to fix deeply nested DSLs
read_uses_flow?: Build stub for Ash.Actions.Flows.Read.
properly set related resource
simpler required attributes behavior
add :subfield option to relates_to_actor_via (#540)
add accessing_from/2 builtin check
rewrite calculation loader
add {set,update,get}_context to Ash.PlugHelpers (#534)
improve compile times with ðª
fix action typespecs
add option set_when_nil? to builtin change set_attribute (#528)
update_actor to Ash.Plughelpers (#532)skip_global_validations? option for actionsdatetime_add was actually datetime_subtract in elixir
prevent exception when describing some checks (#531)
get_by option to read actions. (#530)properly handle multi-resource transaction return values
various fixes in aggregate authorization behavior
use builtin short names for builtin type helper
properly set builtin types
better resource detection of transactions in Ash.Flow
better formatting for branches in flow charts
add :read_action and :authorize? configurations for resource aggregates
Add before_action/1 and after_action/1 to Ash.Resource.Preparations.Builtins. (#526)
add Ash.Type.NewType
add :unknown for all potential facts
optimize policy check running with laziness
don't select when running policy queries
false on forbidden errorsApi.can? and Api.canactor back to transaction metadatadelay_global_validations? action optiondon't reselect fields automatically
ensure data layer is compiled
reselect_all? option for loadingresource_to_query/2support nil values in dump_to_native
properly support calc expansion in policies
support nil cast for resource type
support record's as calculate arguments
include actor in all calculation context
properly handle list args for functions
set query context from before_action hooks into initial query
set context into initial_query
make resource diagram task recursive
use private.internal? to bypass require_actor?
properly call run_aggregate_query_with_lateral_join
force variations of set arguments{:ok, page} in all casesauthorize?: true by default on flows, pass actor through
pass actor into engine
handle cases where union type is already atom
various union fixes
make depend_on_resources more reliable
use load/3 for builtin concat calc
Add error message when page is added but pagination is not enabled (#511)
add union type and some tests around it
add union short name
add union type
better operator type casting and expression fixes
add warning on usage of transaction hooks when in a surrounding transaction
add before_transaction and after_transaction
pagination behavior is incorrect
nil as page_opts is acceptable
fix aggregate.uniq?
count/list attributeshandle {:ref, ...} tuple in static syntax
various fast follows to api aggregate functions
pattern match problem in aggregate action
properly handle nested array type constraint validation
update spark for latest doc improvements
better description of action_type check
add more builders
stop running preparations if one of them returns an error
load lazily after action when results are set
fix typespec for Ash.set_tenant/1
registry resource validations transformers -> verifiers
better error message on unknown relationship
use destination query for aggregates, join auth to come later
check changeset.valid? properly on destroys
properly halt on action errors in before_action hooks
no async loads except when loading on initial data
support length constraints on array embeds
support {:ignore, changeset} from error handlers
add read action metadata
upgrade to latest spark for compile time improvements
improve compile times by reorienting some compile deps
add relationships to underlying ecto schemas for better escape hatches
reselect explicitly selected queries on reload
properly surface errors from embedded attributes
use original pkey for ets upsert lookup
properly load depended on aggregates
properly handle functional manual creates
Use proper options in confirm change.
only pass action name in Ash.Changeset.for_action (#476)
properly set the context option on changesets
return proper value from validation
include value in invalid error messages
cleaner inspect for calculations
add set_result for conditional manual actions/caching
update docs to new links formats for ash_hq (#483)
add nil return type to api get/3, read_one/2 and read_one!/2 (#482)
don't load dependencies for calcs in query
add action_is/1 builtin validation
more compile time optimizations
properly load depended on aggregates
properly handle functional manual creates
Use proper options in confirm change.
only pass action name in Ash.Changeset.for_action (#476)
properly set the context option on changesets
return proper value from validation
cleaner inspect for calculations
add set_result for conditional manual actions/caching
update docs to new links formats for ash_hq (#483)
add nil return type to api get/3, read_one/2 and read_one!/2 (#482)
don't load dependencies for calcs in query
add action_is/1 builtin validation
more compile time optimizations
properly handle functional manual creates
Use proper options in confirm change.
only pass action name in Ash.Changeset.for_action (#476)
properly set the context option on changesets
return proper value from validation
add set_result for conditional manual actions/caching
update docs to new links formats for ash_hq (#483)
add nil return type to api get/3, read_one/2 and read_one!/2 (#482)
don't load dependencies for calcs in query
add action_is/1 builtin validation
more compile time optimizations
Use proper options in confirm change.
only pass action name in Ash.Changeset.for_action (#476)
properly set the context option on changesets
return proper value from validation
update docs to new links formats for ash_hq (#483)
add nil return type to api get/3, read_one/2 and read_one!/2 (#482)
don't load dependencies for calcs in query
add action_is/1 builtin validation
more compile time optimizations
Use proper options in confirm change.
only pass action name in Ash.Changeset.for_action (#476)
properly set the context option on changesets
return proper value from validation
update docs to new links formats for ash_hq (#483)
add nil return type to api get/3, read_one/2 and read_one!/2 (#482)
don't load dependencies for calcs in query
add action_is/1 builtin validation
more compile time optimizations
properly set the context option on changesets
return proper value from validation
add action_is/1 builtin validation
more compile time optimizations
Api.calculate/3 and define_calculation code interface buildervarious filter & expression fixes
handle aggregate defaults when evaluating expressions
this to parent for claritythis/1 for use inside exists/2 (and other places eventually)various fixes to expression syntax
encode the keyset for display in a URI automatically
fix authorize? method (#472)
calculations depending on aggregates were not including those dependencies properly
load types marked with cast_in_query? false at runtime
proper support for nested expressions in calculations
typo in cast_in_query?
allow lists in expr syntax
warn on potentially incompatible relationship attributes
add default_belongs_to_type configuration
loading an attribute is now equivalent to ensure_selected
support module attributes in exprs
Add Ash.Error.Invalid.TenantRequired error (#471)
add constraints to query calculations
cast_in_query? takes constraints
support for calculations in aggregate fields
simple_notifiers as a compile time optimizationhandle nil constraints in array
only start transactions for resources not already in one
import builtins at the action level, not the section level
fix broken default behavior around managing relationships.
fix tests to handle new defaults
optimize strict checks
properly include module in doc links
add test for string generator, and fix it
only allow nil in appropriate circumstances in generator
respect selects in related_query (#464)
use action name not struct for embedded generators
use create generators for embedded types
support dependencies on pruned branch steps
ensure type compiled for generator
fix decimal generator to only compare with floats at generation
filter min_length strings in generators
failure_mode: :stopdepend on latest spark
different formats for extensions
:struct (Ash.Type.struct) typereplace doc links in sidebar also
better doc replacement behavior
dep updates & new aggregate types avg/min/max/custom
more matching fixes on manual relationships
handle manual relationship load results when building query
only set defaults when attribute is actually set
Pass context into query and changeset for_... functions. (#460)
don't run calculation queries if no records were returned
don't run queries with limit: 0
more readable flow charts
not_found_error? option on get?: true read flow steps
not_found_error? option to interface builder and when callingdon't raise a backwards incompatible error message on certain changeset functions
properly apply managed relationships on manual actions
properly pass resource option in filter policies
don't revisit nodes in the ash engine
properly map to :destroy step names
handle Ash.Flow.Step.Destroy in path matchers
resolve issue with authorize_unless and filter checks
fix pattern match error in manage relationship reduce
optimize various solver boolean optimizations
more comprehensively remove unnecessary clauses
prevent changing attributes and arguments after action validation
add error context to error creation / normalisation (#440)
update hexdocs processor to link guides on hexdocs
return invalid primary key errors for Api.get when the input can't be cast
much more readable errors when building loads
better check module validation
reselect relationship source fields when loading relationships
make plug an optional dependency of Ash
where and or_where implementationwhere and or_where to exprproperly pass a map to manual action context
destroy action types default to accepts [] (#453)
various typespec/build fixes
handle tuples properly in some cases in expression syntax
Add missing [:ash, :query] telemetry (#451)
improve runtime expression running
add default description for filter checks
validate that modules exist and are documented when referenced
don't incur compile time dependency for resources used as types
allow for not-yet-compiled resources as Ash types
properly raise error on invalid type.
properly set error vars with list constraints
when creating changesets/queries that already have arguments, revalidate arguments
update to latest spark
support statically configured upsert actions
add more builders
fix depend on resources to depend on each resource
allow references on both sides of in
properly upsert all explicitly changed fields
traverse maps for template_references_actor?/1
These include:
- custom create/read/update/destroy actions
- changes
- preparations
- validations
- calculations
- manual relationships
See the respective DSL guides for more.
don't add required belongs_to error if changeset is invalid (#437)
don't lazy load when managing relationships
support anonymous functions for various behaviour based options
add more ergonomic manual action definitions.
more additions to the resource builder, update spark
Ash.PlugHelpers: standardise conn interface for actors/tenants. (#432)
add Ash.Resource.Builder, the start of DSL builder utilities of rextension writing
DataLayer: incorrect typespec for run_query/2 callback. (#431)
in Ash.Seed, don't try to update a non-loaded record
properly load manual to_one relationships
properly compare against decimal values
pass tenant to calculation query explicitly
allow using get_path/2 by name, as well as bracket access
SVG, PDF, PNG, Markdown and plain mermaid formats (#428)
optimize nested exists filter statements
support floats & decimals in the compare validation
Ash.Api.Info.depend_on_resources/1 to get the list of resources at compile timeApi.load/2when returning a page, choose keyset if before or after was supplied
add keysets to records if any action supports keysets
show conditions in policy breakdowns
A compile env can be set to allow customizing the available type short names. This supports two things:
attribute :price, :money mapping to MyApp.Type.Moneyattribute, :price, :string mapping to a custom string type implementation (there is likely no reason to do this)
Commit with unknown type in: feat: Custom short names for types (#423)See the docs for Ash.Type for more information
now() to expressionsThis helps with things like https://github.com/ash-project/ash_phoenix/issues/57 which involve rendering the relationship value after editing it. Retaining the order allows direct reuse without any gymnastics
basic livebook generator and mix task (#420)
mermaid class diagram mix task (#417)
properly lateral join when possible
use prepend?: true when applying relationship sorts
don't miss dependencies in flow diagrams
fix deps finding in flow charts & flows
properly load calcs/aggs on manual relationships
properly load nested manual relationships
allow overriding validation message on a list of errors (#412)
reraise errors on task error
don't show dependencies for run_flow steps in expanded view(they are duplicates)
don't eager evaluate type/2
support depending on requests that will be added
support dynamic action steps in Ash.Flow
add prepend?: true option to sort
use simple_equality?/0 to allow for optimized equality checking
mermaid mix task for ER diagrams (#415)
try to resolve flaky tests by not using named tables for private ets resources
better unknown error handling
allow passing query or changeset in can/can?/4 (#410)
handle upsert_identity better with ets/mnesia
always set source on attributes
Improve error when actions reject and accept keys overlap (#405)
update to latest spark
fix chart links rendering
make loading?/2 know about calcs and aggs
properly set source on attributes
policy fixes from pair session (#403)
don't evaluate expressions incorrectly after casting
add type function to ash core
Allow a single where condition for validations (#407)
haltable flows, branch step type
simplify async task strategy
clean up new create authorization simplification
remove the need for SetTypes
add some info to policy errors
experimental support for calculations accepting expression arguments
various Ash.Flow improvements, including returning the new Ash.Flow.Result
show_private? option for diagrams (#396)
generate mermaid entity relationship diagrams from a given api (#376)
add back in new/2 to Changeset
properly load nested calcs
switch from no_depend_modules in most places
properly display compare/2 error message
use the short type for aggregate types
kind_to_type/2 returns tagged tuple
allow select/load callbacks for calcs to return irrelevant keys
optimize load equality matching by not using Comp
Forbid reserved field names (#388)
validate accepted and rejected attributes in actions (#395)
support zero argument functions in compare/2
relates_to_actor_viause at_path when parsing Exists
properly require a condition of a following bypasses
don't transform == nil to is_nil automatically
pass path down to keyword list errors
bad pattern in filter.ex, fix dialyzer
attempt to evaluate filter checks for strict checks
only return errors when there actually are errors
return an error if data_layer_query/2 is given a query with errors
various fixes with complex policy statements
ensure fields selected in-line when loading calcs
handle statically false conditions in filter logic
cast embedded datetimes properly
Ash.Calculation: fix return type for load/3 callback. (#384)
warn instead of raise on :replace usage
handle var_args expression with literal args
catch more cases in preflight authorization checks
lazily set required loads/selects for calcs/sorts
reselect any necessary fields when loading calcs
set context when creating related filters allowing checks like filtering_on
simplify filter statements further
don't overconstraint filters on related data
any filter being statically true means :authorized
properly mark conditions w/ access_type
use IsNil instead of Eq when either side is nil
handle string dates for embeds
remove timestamps in favor of simpler macro
replace_relationship typeproperly handle args/nested expression for tuple calcs
add a case for calculations as tuples in expr filters
return count, not {:ok, count}
bad return value when async fetching counts
remove dbg() call
update to latest spark, support dsls in resource info
deprecate :replace in favor of :append_and_remove
add loading?/1 query helper
add loading/1 built in check
nil casts as any type (sort of)
return nil on nil inputs for length/1
properly reraise errors raised in tasks
properly return errors from tasks
use Comp.equal?/2 when finding loaded data matches
properly error on types when evaluating expressions at runtime
properly surface errors all the way from runtime filters
properly catch errors when running expressions at runtime
validate aggregate paths supported
add filterable? option to relationships
add data layer capability for aggregate relationships & filter relationships
add guide on manual relationships
fix keyset pagination ordering bug
short names are snake cased
properly do pagination
handle pins in exists
add better error for exists/2
use root_resource for related path in filter
add match/3 to upgrading guide
set root_resource in exists parsing
error fetching relationships in filter expressions
filter check typespecs
add aggregate_type/2 helper
make two queries for full keyset pagination support
exists/2 expressionforbid_unless were not wrongforbid_unless expression compilation
fix runtime filter join simulation for multiple rows
False default value for argument is nil in changeset (#364)
ignore belongs_to in preflight attribute check
clean up relationship validation logic
clean up logic around preflight belongs_to validation
add value_is_key option for managed relationships
Replace usage of Timex.shift with builtin Calendar functions (#362)
handle required but not accepted values better
properly set authorize?: false on runtime filter
explicitly don't authorize the runtime filter authorization logic
fix eager function/operator evaluation
scrub values properly, same as last bug
map update bug when sanitizing boolean expressions
fixs runtime filter fallbacks
support authorize? as a changeset option
add actor_present policy
add error? option to get
fix various operator evaluators
actually use warn_on_empty? config
check for actor on query/changeset for actor context
pass actor opt down
don't skip setting tenant when actor is present
don't use apply/3 on kernel macros
small bug in DSL transformer manipulation.
&& and || don't short-circuit to nil
{:ok, _} -> {:known, _} when evaluating operators
fix bad evaluation case for operators
ensure we only take unique related records when lazy loading
add warnings to DSL transformer returns
warn on empty registries
better sanitization around sensitive attributes in filters
change always_authorize? to authorize for multiple options
add error message for manual action missed
Map.get/2 when getting paths if the value is a structadd || and && operators
sort parsing helpers
add Ash.Sort.parse_input!/2
add transfer_context/1 and get_context_for_transfer/0
add process-based actor, tenant and query/changeset context
add always_authorize? and require_actor? to api config
support paths in actor/1
add can?/4 policy utility (#349)
add can?/4 policy utility
make mnesia and ets work properly when sharing tables
make updates properly merge with mnesia and ets
attribute_writable? also makes it public
code_interface optional arguments
improve behavior of lazy?: true option
add back in writable? option to relationships, and add attribute_writable? to belongs_to
don't rescue arbitrary exception/exits
add back in DSL docs
add match_other_defaults? to attribute
fix return type for dump/3 ecto type
load/3 returns {:ok, value} | :error
remove relationship writability, as it all happens through arguments now
repurpose writable? on belongs_to to make the attribute writable
bad return value for destroy! + return_notifications?: true
use digraph to order transformers
things breaking due to stricter expectations on type function inputs
depend on all entries in registry
Ash.Generator
add Ash.Seed module with seed helpers
add basic type handling for non embedded resources
better transformer ordering error
don't pay massive costs of a function undefined error
optimize related resource inclusion check
don't disable lexical tracker for extensions
properly set the changed? context
always return all notifications if return_notifications?: true
read file at compile time for doc index
when casting atom -> string, stringify it first
add resource to notification warning
add config :ash, :pub_sub, debug?: true
add from to notification, and notification_metadata to api
move preparation init to runtime
don't automatically url encode keyset values
fixed bug where embedded resources would always provide defaults, not allowing you to declare your own (primary?) actions (#339)
keyset pagination counts all rows
fetch items closest to cursor by reversing keyset sort
keyset + before results must be reversed
add identity_priority and use_identities option to manage_relationship
support limit in simple data layer
add key to InvalidKeyset error
better error message on invalid keyset
added options to the built-in function relate_actor/1 (#332)
add :_pkey shortcut in pub_sub
validate pre_check_with is set for ets/mnesia identities
clearer and raised error message on changeset action mismatch
accept atoms when casting strings
rename interval to duration_name
Fix concat (#326)
Make get and get! consistent with what they raise when no record found (#325)
{:ok, nil} on nil cast for stringsAsh.Policy.Authorizerensure that the default accept is used
distinct before limit and offset
add distinct in data_layer_query
merge calculations when merging loads
add no_depend_modules for changes/validations
match on :unknown not {:ok, :unknown}
run calc in data layer if it returns :unknown
don't ignore lexical tracker on modules in DSL
don't treat single actions of a type as primary
render contributor images correctly in hexdocs (#321)
go back to old method of checking for resource
properly load from load statement in calculations
send notifications in all cases
use unpaginated read when loading
properly handle errors in mnesia transactions
default custom steps to be async?: false
get tests/dialyzer passing
work on module dependencies
use new no_depend_modules everywhere
add no_attributes? relationships
add manual read actions
calculation values from requests
small optimizations
more flow features/fixes, debug step
work on transaction flow steps
Handle date type cast_input with nil value (#311)
fix expression logic
don't throw away timeout exit
timeouts @ the engine, not the parent process
timeout logic was timing out after the fact
uniqueify list_refs even further
flaky test issue
Enforce unique action names (#308)
pass tenant option to requests properly
Fix typespecs in Ash.Api (#307)
fix resource relationship validation
fix paths for load in flow
aggregate/calculation filter issues
show error message in NoSuchResource
import builtin preparations in global preparations block
load on cast_stored in embedded type
add descriptions to mermaid charts/flow
tons of engine/timeout improvements
implement NaiveDateTime type (#312)
Improve usability of finding by primary key (ID) (#294)
Add time type matching existing date type (#310)
flow -> mermaid chart
flow tenants
fix nested map statements in flow
add dynamic allow list
uniqify list_references
set default timeout to 30_000
remove coverage from CI
fully deprecate the resource entity
add eager validate identities
percolate nil values in operators in ash expression language (like SQL)
add return_destroyed? option
add api option to relationships
make default actions and primary actions far more explicit
better error messages on unknown
better loading behavior for managed relationships
add lazy? option for loading
show value in atom error list
add modify_query callback
add overview
add build_entity!
properly parse {:_ref, path, name}
add deselect to build
validates attributes and relationships have unique names (#300)
validate no embeds in api
add Ash.Flow
support recursive DSL entities.
manual relationships
add load option convenience for reads/code interface
handle errors in all action types where changeset wasn't resolved
always sanitize requests before we spawn them
context name in loading manual relationships
get aggregate query from proper engine path
handle error case in create
don't require attributes if an argument overrides them
fix hanging issue when adding engine requests
don't require writable?: false attributes
pull aggregate values properly
fix nested section configs having wrong path
don't rescue errors in resource_formatter
add input/2 to resource modules
move back to more efficient formatter
make the formatter safer, again
typo in changeset.ex (#291)
properly attach authorization_filters to loaded items
add ref template helper
add transaction steps to flow
unimport to avoid name collisions in nested DSLs
disable lexical tracker when expanding aliases
temporarily move init to runtime for changes
don't blow away sections when formatting
properly reorder sections in the formatter
source option to attributescast_in_query?/0 to Ash.Typeinclude a missing module
properly set filterability on attributes
initial implementation of ash resource formatter
ensure no reserved names can be used as constraints
if and is_nil functionsash_struct_fields to accumulate schema struct field defaultsdon't call add_aggregates w/ a map
allow new filter pattern in typespec
add where to change
support data layers bulk adding aggregates
do_reverse_relationship_path/3add more authorizer state management
customizable exception for authorizers
support new versions of ecto's struct fields
fixes for elixir_sense plugin
add Ash.DataLayer.Simple.set_data/2
complete mutually_exclusive_and_collectively_exhaustive logic
undo an unnecessary contains change
WIP attempt to resolve ci_string typing errors
Query.equivalent_to?missing rename on refactor
typo in unquote
mark contains as a predicate
expose small filter helpers
make to_simple_filter fail better, add failure option
Transformer.eval/3 (for special use cases only)Ash.Query.equivalent_to/2subset_of? and superset_of? query macrosrun calculations inline by default
use Date.add when using LessThanOrEqual with date value (#281)
cast nil input on strings
support do/else blocks in if
support cond
don't ask the data layer to sort if no sort is applied
set tenant at start of query build (#278)
:uuid for Ash.Type.UUIDonly_when_valid? on changescorrectly handle errors in validate_required_belongs_to (#276)
set actor when loading to manage belongs_to
cast to string before concatenating
action into data layer contextdefault option for aggregatesload when running calculation queriesadd allow_async? to calculations, default to false
add elixir evaluation step to expression calculations
global resource preparations
Ash.Sort.parse_input/2get_by and get_by_identity on bang (!) interfacesadd get_by and get_by_identity to code interface
compile time validations for managed relationships
primary_actions? optionbreaking change! api level code interface removed, contact me on discord if you want a way to avoid changing to resource-based interface, but otherwise
use proper equality checking in places where we were using simple elixir equality checking
move related field validations to resource
remove join_attributes, which didn't do anything anyway
handle errors when validation calculation constraints
remove certain modules from avoiding recompilation
module_prefix for dsl extensionsensure changeset is up to date in after_action hooks
fix a case where unwrap_or_raise! returned the wrong value on destroy
fix typo on lateral join checker
set default attribute type (in case it is explicitly set to nil) on belongs_to attributes
if an error with no message is produced, don't attempt to concat nil with a string
simpler patterns around soft destroy actions
add set_option/4 to transformer helpers
add where option to validate that accepts a list of validations
prevent more unnecessary lateral joins
only issue a lateral join when required (#269)
support on for global changes
return proper result when input is struct
remove File.read! from docs
skip resource action if no changes have been made
add changing_attributes?/1 to determine if any attributes are changing
add global changes
upgrade docs/tooling for elixir_sense
set docs statically
transformer/extension improvements
add path to errors
set tenant properly on create interface
update type spec for Ash.Sort to include single atom instead of only list. (#263)
pass constraints to sub-fields loaded in embeddable resources
take creates into account w/ attribute_equals and attribute_does_not_equal
set changeset in destroy authorization request
return not found in all cases on get
don't allow get! to return nil
don't do db filters on creation
honor allow_nil_input in required validations
add after_action option to create/update
add config :ash, disable_async?: true
add meta[:order] option for managed relationships
update to latest picosat_elixir for releases
cast nil enum values properly
set api in destroy action hooks
support action level metadata
add on_match: :destroy option
if a map is given for a list, take it's keys
set better error paths for invalid relationships
include api in changeset inspect
set argument defaults early
don't add indices to non-list inputs in managed relationships
redact fields in the resource struct as well
allow before_action to manage belongs_to relationships
load belongs to relationships before managing them
don't lookup nil input
don't look for matches for nil
don't accept list inputs for managed belongs_to
don't use list inputs in belongs_to managed
remove belongs to related after action
fix more cases where belongs_to isn't replaced
honor on_missing: behavior for belongs_to relationships
properly remove old belongs_to records
belongs_to attributes after the others:exitcatch normal exit message from engine
flush engine state always
Ash.Resource.Info: add &public_field/2 helper (#254)
Ash.Resource.Info: add &sortable?/3 helper
load calculations from sorts properly
rename conflicting test name
fix complex attribute check
disallow aggregate/calculation sorting w/ keyset pagination
ensure calculation compiled
don't limit/offset aggregate queries
get_type in cast_stored againspeed up type loading
add __order__ field to be used by data layers
force? option to apply_attributes/2add in error paths for managed relationships
set error paths on managed rels
always replace error message vars
minimize relationship source changeset context inspect size
cast empty string to nil in atom
accept strings for atom types again
don't turn strings to atoms in :atom type
don't do unnecessary validation in type
required? flag for has_oneproperly determine reverse aggregate relationship
ensure calculation modules are compiled
attempt to fix calculation compile time issues
allow sorting on aggs, w/o loading
ensure query in ensure_selected
handle sorting empty data properly
manage ets tables properly
link request handler to engine and runner, solve mem leak
ensure ci_strings casted after constraints
Revert "more optimized types"
revert a suboptimal change to the type system
don't call type() on :string
optimize ash type loading
if "" fails to cast, cast it as nil instead
ReadActionRequiresActor error
ensure_selected change
don't perform match on nil
add {:arg, :name} input for set_attribute
revamp ci_string
add Ash.Type.type/1
more optimized types
ensure query in ensure_selected
handle sorting empty data properly
manage ets tables properly
link request handler to engine and runner, solve mem leak
ensure ci_strings casted after constraints
Revert "more optimized types"
revert a suboptimal change to the type system
don't call type() on :string
optimize ash type loading
if "" fails to cast, cast it as nil instead
ReadActionRequiresActor error
ensure_selected change
don't perform match on nil
add {:arg, :name} input for set_attribute
revamp ci_string
add Ash.Type.type/1
more optimized types
handle sorting empty data properly
manage ets tables properly
link request handler to engine and runner, solve mem leak
ensure ci_strings casted after constraints
Revert "more optimized types"
revert a suboptimal change to the type system
don't call type() on :string
optimize ash type loading
if "" fails to cast, cast it as nil instead
ReadActionRequiresActor error
ensure_selected change
don't perform match on nil
add {:arg, :name} input for set_attribute
revamp ci_string
add Ash.Type.type/1
more optimized types
link request handler to engine and runner, solve mem leak
ensure ci_strings casted after constraints
Revert "more optimized types"
revert a suboptimal change to the type system
don't call type() on :string
optimize ash type loading
if "" fails to cast, cast it as nil instead
ReadActionRequiresActor error
ensure_selected change
don't perform match on nil
add {:arg, :name} input for set_attribute
revamp ci_string
add Ash.Type.type/1
more optimized types
ensure ci_strings casted after constraints
Revert "more optimized types"
revert a suboptimal change to the type system
don't call type() on :string
optimize ash type loading
add {:arg, :name} input for set_attribute
revamp ci_string
add Ash.Type.type/1
more optimized types
ensure ci_strings casted after constraints
Revert "more optimized types"
revert a suboptimal change to the type system
don't call type() on :string
optimize ash type loading
revamp ci_string
add Ash.Type.type/1
more optimized types
Revert "more optimized types"
revert a suboptimal change to the type system
don't call type() on :string
optimize ash type loading
add Ash.Type.type/1
more optimized types
revert a suboptimal change to the type system
don't call type() on :string
optimize ash type loading
add Ash.Type.type/1
more optimized types
error_handler for create/update/destroy actions:infinity on engine genserver callshide metadata field on inspect
load relationships required for calculations (optimize later)
don't halt on request handler failure
properly error when more than 2 requests of the same type are primary
properly process sort when the sort is an atom
properly calculate reverse relationship paths
constraints on calculations
better calculation inspect
allow supplying stacktraces when building errors
expression based calculations for filterable/sortable calculations
expression calculations for sorting/filtering
add compare validator (#242)
aggregate authorization issues
ensure create functions generated by code_interface accept tenant in the opts list (#243)
tons of improvements across the board
small improvements/fixes across the board
Update remaining builtin validators (#244)
properly process managed belongs to relationships
cast nil -> {:ok, nil} in all cases
set tenant even on non-tenant resources where relevant (#241)
select calculation optionadd validate_destination_attribute?
add builtin select change
args combo errorupsert_identity optionignore?: true still accumulates changes
properly require_attributes before setting defaults
ignore? option for manage_relationship changeexpose default_value/1 in aggregate
transactions for reads, notifications from read callbacks
on_no_match: :match supported for to_one relscontext -> relationship_context to avoid conflictset __source__ context for embeds
utility manage_relationship_source context
run action changes on destroy
pattern match manage_relationship notifications fix
add manual? option for create/update/destroy
ensure data layer can perform aggregates
support filtering on related aggregates
autoload aggregates used in filters
IsNil function to IsNil operator
function clause match error in not expression
don't consider contextual relationships as reverse relationships
support not in query expressions
read_action optioninner later join for many to many relationships
support relationship filters
has filter predicate:list aggregate kindNotLoaded in manage_relationshiprequire_attributes to create/update/destroyadd first class support for enum types
Add detailed parameter checking for Api read functions (#229)
clearer errors when resource fails to compile
don't preload multiplicatively
Decimal casting issues on ash_postgres (#227)
add list access to context
add Resource.input/1
load relationships for management properly
fetch_key bug in embedded types
handle_indexed_maps for embedded types
NotFoundembedded cast_stored must cast all key/values
ci_string constraints when nil
manage_relationship change turns embedded resources to maps
fixes for common types parsing from embedded, e.g utc_datetime_usec
get! should raise on nil not {:ok, nil}get?: true interface functions to raise on nilallow_nil -> allow_nil_input
allow api.load/2 to load calculations
add allow_nil_input to create actions for api layers
add load/1 builtin change
get?: true interface functions to raise on niladd allow_nil_input to create actions for api layers
add load/1 builtin change
update struct_field logic for latest ecto
apply proper interface operation when opts aren't passed
support Ash.Query.distinct/2
add build/2 query preparation
before_action? on validate, validate inlinesupport Ash.Query.distinct/2
add build/2 query preparation
don't overwrite managed belongs_to relationships
handle on_lookup + on_no_match for belongs_to
fix required relationships and add test
fix required relationships
various managed_relationship fixes
fix required relationships and add test
fix required relationships
various managed_relationship fixes
don't accept relationships on actions anymore
require arguments
support type aliases in more type casting functions
support tenant option in read interface
tenant option in read interfacedon't require values when managing relationships
Revert "fix: force_change_attributes before passing to action"
exception on invalid query arguments
allow casting strings as uuids (for embedded types)
avoid exception in Changeset.new/2 for bad attribute
use ecto's uuid type under the hood
for_*Ash.Error a public moduleset source_attribute when replacing belongs_to relationship
don't consider false as absent value
set argument name in manage_relationship
forcechange attrs _after for_create/update
pattern match errors in manage_relationships
clean up some error cases
only default accept to public attributes
allow_nil?: false + default interaction
as optionproperly validate allow_nil?: false on update
properly validate allow_nil?: false private attributes
fix pub_sub on update
fix publish_all pub_sub notifier
derive has_one destination_attribute
finalize code API logic
add not_found_message + violation_message for relationships
support get_by_<identity> in interface
support sublists in pub_sub topics
support :_tenant in pub_sub topics
tenant in for_readfunctional interface on the Api module
resource aliases
update interface to accept query/changesets
require completely unique action names
Ash.Query.select/3 and Ash.Changeset.select/3various validation lifecycle fixes
don't fetch sideloads for empty data
treat empty string as nil in manage_relationship
be more conservative (and more correct) when optimizing predicates
treat empty string as nil in manage_relationship
be more conservative (and more correct) when optimizing predicates
mange_relationship changemany compile time fixes via code splitting
Guess destination_attribute for has many relationships (#187)
Implement string length validation (#183)
many compile time fixes via code splitting
Guess destination_attribute for has many relationships (#187)
Implement string length validation (#183)
add default_context
add manage_relationship/4
add relationship specific context (for postgres polymorphism)
add reject (opposite of accept)
manage_relationship for belongs_toset_context change/preparation
set accept by default
{:filter, _} authorization results for changesetsonly run authorization once per request
don't error on replacing empty relationship with empty
support tenant option to get/2
support message option on identities
after_action for queriesdata_layer_querycontains/2 query functionadd action filters in for_read/3
don't let local runner processes mix up messages
runtime filter filters properly
freeform expressions
validatiosn in actions
query arguments
add Ash.Query.for_read/3
return changeset with API errors
add case insensitive string CiString/:ci_string
support context/1 and arg/1 in filter templates
support targeting notifications with the for option
add ago/2 query function
add basic arithmetic operators (+, *, -, /)
sensitive? option for attributes
sensitive? option for arguments
private arguments, which canât be set using for_<action>
add prevent_change which will erase changes just before the changeset is committed
add match? validation that supports a custom error message
add interval type to support ago/2 function
add url_encoded_binary type
add function type
support all string constraints for ci_string
changing? is now a validation
add Transformer.get_persisted/3
add api field to Notification
standardize errors, add to_error_class
use Comp everywhere
use action on changeset if set by for_<action_type>
action_failed? field on change sets
remove ability for data layers to add operators (for now at least)
Changeset.apply_attributes/2 now returns an error tuple
add a bunch of new/informative errors
runtime filter now uses left join logic (a naive implementation of it)
support more filter templates in resources
basic/naive type system for operators/functions
Add trim/allow_empty to string type (#171)
Ash.Sort.parse_input/2allow_nil?: false for integer_primary_keyfor_<action> helpers__resource__ change broke some extensionsextensions/1 helper to resourcesoptimize not-in and fix dialyzer
rework filter creation + subset checking
parse_input/3 to Ash.Filteraggregate/5support :first aggregate (#153)
support more sort orders
examples on dsl sectionscast string argument names
uuid/id pkeys should allow_nil
various pagination, runtime, and auth bugs
default pagination limit triggers pagination
various build fixes
various small utility fixes
update get-tag
remove unused code
various fixes and improvements
add notifiers (#133)
Add :one_of constraint to the Atom type (#130)
fix dialyzer
fix certain versions of elixir having issues
filter rewrite to op/function/ref based structure
added description for missing resources (#117)
add module name to errors (#127)
Fix composite key in changeset functions (#125)
upgrade picosat dependency
correct comment in UUID type (#115)
set_attribute builtin change
(greater_than/less_than)_or_equal predicates
support deletes as updates via "soft"
support base_filters
remove delegate data layer (#112)
delete process/global storage properly
required belongs_to relationships (#107)
support filter templates on read actions
builtin concat calculation
add changes to actions (#106)
add accept option to create/update actions (#105)
add Ash.NotLoaded back, simpler defaults
improve errors (add stacktraces)
various delegate data layer improvements
engine halting issues
resolve engine deadlocks
support nested lists of filters
add one_of validation
add simple data layer, and make it default
only update filter when its a filter
set resource in delegation query
support inner lateral joins (#100)
add identities, to enhance get calls (#99)
initial calculation support (#98)
initial calculation support
spec + dialyzer fixes
spec mix task run as no_return
load by accepting ok/errorextensions: resolve duplicate nested entities
use Ecto's NotLoaded for assocs for now
create/update typespecs were wrong
is_nil predicateadd lexical scope to DSL for imports
crash on entity w/ no options specified
convert eq: nil into is_nil, fix credo
load typespecsgroup metadata by path and async?: false
run aggregates async if not in query
aggregations!
on_loadlots of docs, simplify query generation
validate relationship keys
list types
refactor ash types to modules, add constraints
remove benchee, ensure mnesia always uses transactions
try clearing cache to fix CI
stop gitignoring the mnesia data layer
try to fix ash.formatter task
test/improve parallelizable requests
require that resources have primary keys
add less_than and greater_than filter support
validate all related resources in API
fix tests/credo
fix tests, add tests for gt/lt filters
cross data layer filters
cross data layer filtering
raised error message contents
parent error messages
relationship path clause
boolean filter refactor (#78)
predicate behaviour
rebuild DSL inner workings for extensibility (#70)
add after_compile and validate primary key
dialyzer warnings
honor the authorize? flag
date support (#68)account for action/actor args to interface
remove the rest of the deps on name/type
add resource_module?/1 back to Ash
references to error handling code
fix empty filter checks
This release is a test of our automatic hex.pm package publishing
This release is a test of our automatic hex.pm package publishing
This release is a test of our automatic hex.pm package publishing
This release is a test of our automatic hex.pm package publishing
This release covers the initial linting/dialyzing improvements