glesia

Safe-ish Gleam bindings for Erlang Mnesia.

Glesia wraps the common Mnesia lifecycle and data operations while keeping the dynamic BEAM boundary explicit. Table names and attributes are atoms; records cross the FFI boundary as Dynamic values and can be decoded by callers with normal Gleam decoders.

Types

InsertNewResult

</>

pub type InsertNewResult {
  InsertNewInserted
  InsertNewExists
  InsertNewError(reason: dynamic.Dynamic)
}

Constructors

```
InsertNewInserted
```
```
InsertNewExists
```
```
InsertNewError(reason: dynamic.Dynamic)
```

MnesiaError

</>

pub type MnesiaError {
  AlreadyExists
  NotFound
  Timeout
  BadType(String)
  Abort(String)
  Unknown(String)
}

Constructors

```
AlreadyExists
```
```
NotFound
```
```
Timeout
```
```
BadType(String)
```
```
Abort(String)
```
```
Unknown(String)
```

ReadResult

</>

pub type ReadResult {
  ReadOk(records: List(dynamic.Dynamic))
  ReadError(reason: dynamic.Dynamic)
}

Constructors

```
ReadOk(records: List(dynamic.Dynamic))
```
```
ReadError(reason: dynamic.Dynamic)
```

SchemaResult

</>

pub type SchemaResult {
  SchemaOk
  SchemaError(reason: dynamic.Dynamic)
}

Constructors

```
SchemaOk
```
```
SchemaError(reason: dynamic.Dynamic)
```

SimpleResult

</>

pub type SimpleResult {
  SimpleOk
  SimpleError(reason: dynamic.Dynamic)
}

Constructors

```
SimpleOk
```
```
SimpleError(reason: dynamic.Dynamic)
```

StorageType

</>

pub type StorageType {
  RamCopies
  DiscCopies
  DiscOnlyCopies
}

Constructors

```
RamCopies
```
```
DiscCopies
```
```
DiscOnlyCopies
```

TableCreateResult

</>

pub type TableCreateResult {
  TableCreateOk
  TableCreateAlreadyExists
  TableCreateError(reason: dynamic.Dynamic)
}

Constructors

```
TableCreateOk
```
```
TableCreateAlreadyExists
```

TableCreateError(reason: dynamic.Dynamic)

TableType

</>

pub type TableType {
  Set
  OrderedSet
  Bag
}

Constructors

```
Set
```
```
OrderedSet
```
```
Bag
```

TransactionResult

</>

pub type TransactionResult {
  TransactionOk(value: dynamic.Dynamic)
  TransactionAbort(reason: dynamic.Dynamic)
}

Constructors

```
TransactionOk(value: dynamic.Dynamic)
```

TransactionAbort(reason: dynamic.Dynamic)

Values

create_local_schema

</>

pub fn create_local_schema() -> Result(Nil, MnesiaError)

create_ram_table

</>

pub fn create_ram_table(
  table: atom.Atom,
  attributes: List(atom.Atom),
) -> Result(Nil, MnesiaError)

create_schema

</>

pub fn create_schema(
  nodes: List(atom.Atom),
) -> Result(Nil, MnesiaError)

create_table

</>

pub fn create_table(
  table: atom.Atom,
  attributes: List(atom.Atom),
  storage_type: StorageType,
  table_type: TableType,
) -> Result(Nil, MnesiaError)

delete_local_schema

</>

pub fn delete_local_schema() -> Result(Nil, MnesiaError)

delete_schema

</>

pub fn delete_schema(
  nodes: List(atom.Atom),
) -> Result(Nil, MnesiaError)

dirty_delete

</>

pub fn dirty_delete(
  table: atom.Atom,
  key: dynamic.Dynamic,
) -> Result(Nil, MnesiaError)

dirty_read

</>

pub fn dirty_read(
  table: atom.Atom,
  key: dynamic.Dynamic,
) -> Result(List(dynamic.Dynamic), MnesiaError)

dirty_read_decoded

</>

pub fn dirty_read_decoded(
  table: atom.Atom,
  key: dynamic.Dynamic,
  decoder: decode.Decoder(value),
) -> Result(List(value), MnesiaError)

dirty_write

</>

pub fn dirty_write(
  record: dynamic.Dynamic,
) -> Result(Nil, MnesiaError)

insert_new

</>

pub fn insert_new(
  table: atom.Atom,
  key: dynamic.Dynamic,
  record: dynamic.Dynamic,
) -> Result(Bool, MnesiaError)

Atomically write a record only when no record exists for the given key.

This uses a transactional Mnesia read with a write lock, then writes the record inside the same transaction. It returns Ok(True) when inserted and Ok(False) when the key already exists.

set_dir

</>

pub fn set_dir(path: String) -> Result(Nil, MnesiaError)

start

</>

pub fn start() -> Result(Nil, MnesiaError)

stop

</>

pub fn stop() -> Result(Nil, MnesiaError)

transaction

</>

pub fn transaction(
  fun: fn() -> value,
) -> Result(dynamic.Dynamic, MnesiaError)