Syntropy.Persistence (syntropy v0.1.0)

Copy Markdown

Optional Postgres-backed durability for Syntropy replay-critical read models.

Summary

Types

event()
recommendation()
run_envelope()
snapshot()
task_result()
write_result()

Functions

clear_all!()
counter_from_ids(records, key, prefix)
enabled?()
hydrate_limit()
load_knowledge_items()
load_recent_events(limit)
load_recent_recommendations(limit)
load_recent_run_envelopes(limit)
load_recent_snapshots(limit)
load_recent_tasks(limit)
observe_write(error, operation)
persist_event(event)
persist_knowledge_items(agent_id, items)
persist_recommendation(recommendation)
persist_run_envelope(run_envelope)
persist_snapshot(snapshot)
persist_task_run(task_result)
require_write!(result, operation)
tolerate_write(result, operation)

Types

event()

@type event() :: Syntropy.EventRecorder.event()

recommendation()

@type recommendation() :: Syntropy.RecommendationStore.recommendation()

run_envelope()

@type run_envelope() :: map()

snapshot()

@type snapshot() :: Syntropy.HistoryStore.snapshot()

task_result()

@type task_result() :: Syntropy.TaskScheduler.task_result()

write_result()

@type write_result() :: :ok | {:error, term()}

Functions

clear_all!()

@spec clear_all!() :: :ok

counter_from_ids(records, key, prefix)

@spec counter_from_ids([map()], atom(), String.t()) :: non_neg_integer()

enabled?()

@spec enabled?() :: boolean()

hydrate_limit()

@spec hydrate_limit() :: pos_integer()

load_knowledge_items()

@spec load_knowledge_items() :: %{required(String.t()) => [String.t()]}

load_recent_events(limit)

@spec load_recent_events(non_neg_integer()) :: [event()]

load_recent_recommendations(limit)

@spec load_recent_recommendations(non_neg_integer()) :: [recommendation()]

load_recent_run_envelopes(limit)

@spec load_recent_run_envelopes(non_neg_integer()) :: [run_envelope()]

load_recent_snapshots(limit)

@spec load_recent_snapshots(non_neg_integer()) :: [snapshot()]

load_recent_tasks(limit)

@spec load_recent_tasks(non_neg_integer()) :: [task_result()]

observe_write(error, operation)

@spec observe_write(write_result(), String.t()) :: write_result()

persist_event(event)

@spec persist_event(event()) :: :ok | {:error, term()}

persist_knowledge_items(agent_id, items)

@spec persist_knowledge_items(String.t(), [String.t()]) :: :ok | {:error, term()}

persist_recommendation(recommendation)

@spec persist_recommendation(recommendation()) :: :ok | {:error, term()}

persist_run_envelope(run_envelope)

@spec persist_run_envelope(run_envelope()) :: :ok | {:error, term()}

persist_snapshot(snapshot)

@spec persist_snapshot(snapshot()) :: :ok | {:error, term()}

persist_task_run(task_result)

@spec persist_task_run(task_result()) :: :ok | {:error, term()}

require_write!(result, operation)

@spec require_write!(write_result(), String.t()) :: :ok

tolerate_write(result, operation)

@spec tolerate_write(write_result(), String.t()) :: :ok