diplomat v0.9.3 Diplomat.Entity

Link to this section Summary

Functions

Create a Diplomat.Entity from a Diplomat.Proto.Entity

Extract a Diplomat.Entity’s properties as a map

Generate a Diplomat.Proto.Entity from a given Diplomat.Entity. This can then be used to generate the binary protocol buffer representation of the Diplomat.Entity

Link to this section Types

Link to this type mutation()
mutation() :: {operation, t}
Link to this type operation()
operation() :: :insert | :upsert | :update | :delete
Link to this type t()
t() :: %Diplomat.Entity{key: Diplomat.Key.t | nil, kind: String.t | nil, properties: %{optional(String.t) => Diplomat.Value.t}}

Link to this section Functions

Link to this function extract_mutations(list, acc)
extract_mutations([mutation], [Diplomat.Proto.Mutation.t]) :: [Diplomat.Proto.Mutation.t]
Link to this function from_proto(entity)
from_proto(Diplomat.Proto.Entity.t) :: t

Create a Diplomat.Entity from a Diplomat.Proto.Entity

Link to this function insert(entity)
insert([t] | t) ::
  {:ok, Diplomat.Key.t} |
  Diplomat.Client.error
Link to this function new(props, kind_or_key_or_opts \\ [], id_or_opts \\ [], opts \\ [])
new(props :: struct | map, kind_or_key_or_opts :: Diplomat.Key.t | String.t | Keyword.t, id_or_name_or_opts :: String.t | integer | Keyword.t, opts :: Keyword.t) :: t

Creates a new Diplomat.Entity with the given properties.

Instead of building a Diplomat.Enity struct manually, new is the way you should create your entities. new wraps and nests properties correctly, and ensures that your entities have a valid Key (among other things).

Options

  • :exclude_from_indexes - An atom, list of atoms, or Keyword list of properties that will not be indexed.

Examples

Without a key

Entity.new(%{"foo" => "bar"})

With a kind but without a name or id

Entity.new(%{"foo" => "bar"}, "ExampleKind")

With a kind and name or id

Entity.new(%{"foo" => "bar"}, "ExampleKind", "1")

With a key

Entity.new(%{"foo" => "bar"}, Diplomat.Key.new("ExampleKind", "1"))

With excluded fields

Entity.new(%{"foo" => %{"bar" => "baz"}, "qux" => true},
           exclude_from_indexes: [:qux, [foo: :bar]])

The above will exclude the :qux field from the top level entity and the :bar field from the entity nested at :foo.

Link to this function properties(entity)
properties(t) :: map

Extract a Diplomat.Entity’s properties as a map.

The properties are stored on the struct as a map string keys and Diplomat.Value values. This function will allow you to extract the properties as a map with string keys and Elixir built-in values.

For example, creating an Entity looks like the following:

iex> entity = Entity.new(%{"hello" => "world"})
# =>   %Diplomat.Entity{key: nil, kind: nil,
#         properties: %{"hello" => %Diplomat.Value{value: "world"}}}

Diplomat.Entity.properties/1 allows you to extract those properties to get the following: %{"hello" => "world"}

Link to this function proto(properties)
proto(map | t) :: Diplomat.Proto.Entity.t

Generate a Diplomat.Proto.Entity from a given Diplomat.Entity. This can then be used to generate the binary protocol buffer representation of the Diplomat.Entity

Link to this function upsert(entity)
upsert([t] | t) ::
  {:ok, Diplomat.Proto.CommitResponse.t} |
  Diplomat.Client.error