# `Nebulex.Event.CacheEntryEvent`
[🔗](https://github.com/elixir-nebulex/nebulex/blob/v3.1.0/lib/nebulex/event/cache_entry_event.ex#L1)

A cache entry event.

# `t`

```elixir
@type t() :: %Nebulex.Event.CacheEntryEvent{
  cache: Nebulex.Cache.t(),
  command: atom(),
  metadata: Nebulex.Event.metadata(),
  name: atom() | pid(),
  pid: pid() | nil,
  target: target(),
  type: type()
}
```

Type for a cache entry event.

The event will have the following keys:

  * `:cache` - The defined cache module.
  * `:name` - The cache name, or the cache PID when the cache was started
    without a name.
  * `:pid` - The cache PID.
  * `:type` - The event type.
  * `:target` - The event target: a key, a list of keys, or a query.
    See `t:target/0`.
  * `:command` - The cache command that emitted the event.
  * `:metadata` - The metadata given when the listener was registered.
    It also includes `:extra_metadata` with the per-command metadata
    passed through the `:telemetry_metadata` runtime option.

# `target`

```elixir
@type target() :: {:key, key :: any()} | {:in, [key :: any()]} | {:q, query :: any()}
```

Type for the event target.

The event can target a single key, a list of keys, or a query.

  * A single key: `{:key, key}`. A command writing or deleting a single key
    will use this target. E.g., `put`, `put_new`, `replace`, `delete`, etc.
  * A list of keys: `{:in, [key1, key2, ...]}`. A command writing or deleting
    multiple keys will use this target. E.g., `put_all`, `put_new_all`, and
    `delete_all`.
  * A query: `{:q, query}`. A command deleting entries matching a query will
    use this target. E.g., `delete_all`.

# `type`

```elixir
@type type() :: :deleted | :expired | :inserted | :updated
```

Event type.

  * `:deleted` - Emitted after an entry is deleted, or after a batch
    delete. The commands `delete`, `take`, and `delete_all` emit it. Note
    that `delete` emits it even when the key did not exist, since there is
    no way to know.
  * `:expired` - Emitted when a read finds the entry expired. The commands
    `fetch`, `take`, `ttl`, and `has_key?` emit it.
  * `:inserted` - Emitted after an entry is inserted, or after a batch
    insert. The commands `put`, `put_new`, `put_all`, and `put_new_all`
    emit it, as do `incr` and `decr` when they create the counter. Note
    that for `put` and `put_all` there is no way to know whether the entry
    existed before.
  * `:updated` - Emitted when an existing entry changes. The commands
    `replace`, `expire`, and `touch` emit it, as do `incr` and `decr` when
    the counter already exists.

# `__types__`

```elixir
@spec __types__() :: [atom()]
```

Returns the event types.

## Example

    iex> Nebulex.Event.CacheEntryEvent.__types__()
    [:deleted, :expired, :inserted, :updated]

# `deleted`

```elixir
@spec deleted(Enumerable.t()) :: t()
```

Creates a new `deleted` event.

# `expired`

```elixir
@spec expired(Enumerable.t()) :: t()
```

Creates a new `expired` event.

# `inserted`

```elixir
@spec inserted(Enumerable.t()) :: t()
```

Creates a new `inserted` event.

# `new`

```elixir
@spec new(Enumerable.t()) :: t()
```

Creates a new event.

## Example

    iex> Nebulex.Event.CacheEntryEvent.new(
    ...>   cache: MyApp.Cache,
    ...>   pid: self(),
    ...>   target: {:key, "foo"},
    ...>   command: :put,
    ...>   type: :inserted
    ...> )
    %Nebulex.Event.CacheEntryEvent{
      cache: MyApp.Cache,
      command: :put,
      name: nil,
      pid: self(),
      type: :inserted,
      metadata: %{},
      target: {:key, "foo"}
    }

# `updated`

```elixir
@spec updated(Enumerable.t()) :: t()
```

Creates a new `updated` event.

---

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