# `MishkaCmsCore.Runtime.Resources.Embeddeds.Helper`
[🔗](https://github.com/mishka-group/mishka_cms_core/blob/v0.0.1/lib/mishka_cms_core/runtime/resources/__embeddeds/helper.ex#L5)

Embedded resource for helper function definitions in runtime resources.

This embedded resource represents helper functions that can be defined within
Pages, Layouts, Components, and Error Pages. Helpers allow runtime resources
to include custom Elixir functions that enhance template functionality,
providing reusable logic for data transformation, formatting, and calculations.

Each helper consists of a function name, argument list, and the function body
code. These are compiled into the runtime module as actual Elixir functions,
making them available for use within templates and event handlers. The embedded
nature means helpers are stored as JSON within the parent resource's database record.

Helpers enable dynamic functionality without requiring code deployment, allowing
CMS users to extend the system's capabilities through the UI. Common use cases
include date formatting, string manipulation, calculation helpers, and view-specific
utility functions that simplify template logic.

# `t`

```elixir
@type t() :: %MishkaCmsCore.Runtime.Resources.Embeddeds.Helper{
  __lateral_join_source__: term(),
  __meta__: term(),
  __metadata__: term(),
  __order__: term(),
  aggregates: term(),
  args: term(),
  attrs: term(),
  calculations: term(),
  code: term(),
  discriminators: term(),
  name: term(),
  signature: term(),
  slots: term()
}
```

# `apply_constraints_array`

# `cast_input`

# `cast_stored`

# `check_atomic`

# `default_short_name`

# `dump_to_native`

# `equal?`

# `fetch_key`

# `get_rewrites`

# `handle_change`

# `handle_change?`

# `handle_change_array`

# `input`

```elixir
@spec input(values :: map() | Keyword.t()) :: map() | no_return()
```

Validates that the keys in the provided input are valid for at least one action on the resource.

Raises a KeyError error at compile time if not. This exists because generally a struct should only ever
be created by Ash as a result of a successful action. You should not be creating records manually in code,
e.g `%MyResource{value: 1, value: 2}`. Generally that is fine, but often with embedded resources it is nice
to be able to validate the keys that are being provided, e.g

```elixir
Resource
|> Ash.Changeset.for_create(:create, %{embedded: EmbeddedResource.input(foo: 1, bar: 2)})
|> Ash.create()
```

# `input`

```elixir
@spec input(values :: map() | Keyword.t(), action :: atom()) :: map() | no_return()
```

Same as `input/1`, except restricts the keys to values accepted by the action provided.

# `load`

# `prepare_change`

# `prepare_change?`

# `prepare_change_array`

# `rewrite`

# `storage_type`

---

*Consult [api-reference.md](api-reference.md) for complete listing*