Creates a cache record from the provided values.

A cache record is used to represent the internal state of a cache, and is used when executing calls. Most values in here will be other records defined in the main specification, and as such please see their documentation for further info.

@spec cache(cache(), Keyword.t()) :: cache()

Updates a cache record from the provided values.

Creates a command record from the provided values.

A command is a custom action which can be executed against a cache instance. They consist of a type (:read/:write) and an execution function. The type determines what form the execution should take.

In the case of a :read type, an execution function is a simple (any -> any) form, which will return the returned value directly to the caller. In the case of a :write type, an execution should be (any -> { any, any }) where the value in the left side of the returned Tuple will be returned to the caller, and the right side will be set inside the backing cache table.

@spec command(command(), Keyword.t()) :: command()

Updates a command record from the provided values.

Creates an entry record from the provided values.

An entry record represents a single entry in a cache table.

Each entry has a key/value, along with a touch time and ttl. These records should never be used outside of the Cachex codebase other than when debugging, as they can change at any time and should be regarded as internal only.

@spec entry(entry(), Keyword.t()) :: entry()

Updates an entry record from the provided values.

Creates an expiration record from the provided values.

An expiration record contains properties defining expiration policies for a cache.

A default value can be provided which will then be added as a default TTL to all keys which do not have one set explicitly. This must be a positive millisecond integer.

The interval being controlled here is the Janitor service schedule; it controls how often the purge runs in the background of your application to remove expired records. This can be disabled completely by setting the value to nil. This is also a millisecond integer.

The lazy value determines whether or not records can be lazily removed on read. Since this is an expected behaviour it's enabled by default, but there are cases where you might wish to disable it (such as when consistency isn't that big an issue).

@spec expiration(expiration(), Keyword.t()) :: expiration()

Updates an expiration record from the provided values.

Creates a hook record from the provided values.

Hook records contain the properties needed to start up a hook against a cache instance. There are several components in a hook record:

• arguments to pass through to the hook init/1 callback.
• a flag to set whether or not a hook should fire asynchronously.
• the module name backing the hook, implementing the hook behaviour.
• options to pass to the hook server instance (allowing for names, etc).
• provisions to pass through to the hook provisioning callback.
• a PID reference to a potentially running hook instance (optional).
• the timeout to wait for a response when firing synchronous hooks.
• the type of the hook (whether to fire before/after a request).

These values are mainly provided by the user, and this record might actually be replaced in future with just a behaviour and a set of macros (as this record is very noisy now).

@spec hook(hook(), Keyword.t()) :: hook()

Updates a hook record from the provided values.

Creates a hooks collection record from the provided values.

Hooks records are just a pre-sorted collection of hook records, grouped by their type so that notifications internally do not have to iterate and group manually.

@spec hooks(hooks(), Keyword.t()) :: hooks()

Updates a hooks record from the provided values.

Creates a router record from the provided values.

A router record reprsents routing within a distributed cache. Each router record should have a valid routing module provided, which correct implements the behaviour defined in Cachex.Router.

Options to be passed on router state initialization can also be provided, but note that all other values inside this structure are for internal use and will be overwritten as needed.

@spec router(router(), Keyword.t()) :: router()

Updates a router record from the provided values.

Creates a warmer record from the provided values.

A warmer record represents cache warmer processes to be run to populate keys.

A warmer should have a valid module provided, which correctly implements the behaviour associated with Cachex.Warmer. A state can also be provided, which will be passed to the execution callback of the provided module (which defaults to nil). The flag :required determines if the warmer much execute on cache startup.

@spec warmer(warmer(), Keyword.t()) :: warmer()

Updates a warmer record from the provided values.