# `Dllb.MetaAST`
[🔗](https://github.com/Oeditus/dllb_ex/blob/v0.1.0/lib/dllb/meta_ast.ex#L1)

Serialization bridge between Metastatic's Elixir 3-tuple format
and dllb document/edge storage.

Metastatic AST nodes are represented as `{type_atom, keyword_meta, children_or_value}`.
This module converts them into maps suitable for `Dllb.Query` operations and
handles bulk ingestion of full AST trees into the database.

# `context`

```elixir
@type context() :: %{language: atom(), file_path: String.t()}
```

# `edge`

```elixir
@type edge() :: {String.t(), String.t(), String.t(), map()}
```

# `meta_ast_node`

```elixir
@type meta_ast_node() :: {atom(), keyword(), list() | term()}
```

# `query_fn`

```elixir
@type query_fn() :: (String.t() -> {:ok, any()} | {:error, any()})
```

# `from_dllb_row`

```elixir
@spec from_dllb_row(map()) :: map()
```

Converts a dllb result row (string-keyed map from JSON) into a
ragex-compatible map with atom keys and proper types.

The `kind` field is converted back to an atom via `NodeTypes.from_dllb_kind/1`.
Unknown kinds are kept as the original string in the `:kind` field.

# `ingest_tree`

```elixir
@spec ingest_tree(meta_ast_node(), context(), query_fn()) ::
  {:ok, %{nodes: non_neg_integer(), edges: non_neg_integer()}} | {:error, any()}
```

Walks a MetaAST tree, generates CREATE statements for structural nodes
and RELATE statements for edges, and executes them via `query_fn`.

Returns `{:ok, %{nodes: count, edges: count}}` on success or
`{:error, reason}` on the first failure.

# `to_dllb_document`

```elixir
@spec to_dllb_document(meta_ast_node(), context()) :: map()
```

Converts a single Metastatic AST node into a map of fields suitable
for `Dllb.Query.create/2`.

Extracts metadata from the keyword list: `:name`, `:line`, `:end_line`,
`:source_text`, `:signature`, `:doc`. The `kind` and contextual fields
(`language`, `file_path`) are derived from the type atom and context map.

## Examples

    iex> node = {:function_def, [name: "parse", line: 10, end_line: 25], []}
    iex> ctx = %{language: :elixir, file_path: "/app/lib/parser.ex"}
    iex> doc = Dllb.MetaAST.to_dllb_document(node, ctx)
    iex> doc.kind
    "function_def"
    iex> doc.name
    "parse"

# `to_dllb_edges`

```elixir
@spec to_dllb_edges(meta_ast_node(), context()) :: [edge()]
```

Walks a full MetaAST tree and extracts structural relationship edges.

Returns a list of `{from_id, edge_type, to_id, properties}` tuples.

Edge types extracted:
  - `"contains"` - container -> function_def relationships
  - `"calls"` - function_call edges (caller -> callee)
  - `"imports"` - import edges

# `to_dllb_embeddings`

```elixir
@spec to_dllb_embeddings(String.t(), map()) :: String.t()
```

Returns an UPDATE query string to set embedding fields on an existing record.

## Examples

    iex> embeddings = %{source_embedding: [0.1, 0.2, 0.3]}
    iex> query = Dllb.MetaAST.to_dllb_embeddings("ast_node:MyMod_parse_2", embeddings)
    iex> String.starts_with?(query, "UPDATE ast_node:MyMod_parse_2 SET")
    true

---

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