scriva.client — io.github.srjn45/scriva-client-clojure 1.2.1

Idiomatic Clojure client for ScrivaDB.

Functions take and return plain Clojure maps; streaming RPCs (find, watch, aggregate, snapshot) return lazy seqs. Every call carries the x-api-key gRPC metadata automatically.

(require '[scriva.client :as scriva])
(let [db (scriva/connect {:host "localhost" :port 5433 :api-key "dev-key"})]
  (scriva/create-collection db "users")
  (let [id (scriva/insert db "users" {"name" "Alice" "age" 30})]
    (println (get-in (scriva/find-by-id db "users" id) [:data "name"])))
  (scriva/close db))

aggregate clj

(aggregate client
           collection
           &
           {:keys [aggregations field group-by filter]
            :or {aggregations [] field "" group-by ""}})

Compute count + numeric aggregations. Opts: :aggregations (seq of :count/:sum/:avg/:min/:max) :field :group-by :filter. Returns a seq of {:group :count :numeric :sum :avg :min :max}.

begin-tx clj

(begin-tx client collection)

close clj

(close {:keys [channel]})

Shut the client's channel down.

commit-tx clj

(commit-tx client tx-id)

compact clj

(compact client collection)

connect clj

(connect {:keys [host port api-key tls-ca-cert channel]})

Open a client. Opts: :host :port :api-key, optional :tls-ca-cert (path to a PEM CA cert; plaintext when omitted). A prebuilt :channel may be supplied instead of host/port (used by tests).

count-records clj

(count-records client collection & {:keys [filter]})

Count all live records, or those matching :filter.

create-collection clj

(create-collection client name)

(create-collection client name default-ttl-seconds)

delete clj

(delete client collection id)

delete-by-key clj

(delete-by-key client collection key)

drop-collection clj

(drop-collection client name)

drop-index clj

(drop-index client collection field)

ensure-index clj

(ensure-index client collection field)

find-by-id clj

(find-by-id client collection id & {:keys [fields]})

find-by-key clj

(find-by-key client collection key & {:keys [fields]})

find-page clj

(find-page client collection & {:as opts})

Fetch one keyset page (N3): {:records [...] :next-page-token "..."}.

find-records clj

(find-records client collection & {:as opts})

Stream matching records as a lazy seq of record maps. Opts: :filter :limit :offset :order-by (seq of {:field :desc}) :fields :page-token.

group-by-field clj

(group-by-field client collection field aggregations metric & {:keys [filter]})

Group live records by field and aggregate metric per group.

insert clj

(insert client
        collection
        data
        &
        {:keys [ttl-seconds key] :or {ttl-seconds 0 key ""}})

Insert one record. Opts: :ttl-seconds, :key (caller-supplied primary key).

insert-keyed clj

(insert-keyed client collection key data)

Keyed insert under key; throws :already-exists if taken.

insert-many clj

(insert-many client
             collection
             records
             &
             {:keys [ttl-seconds] :or {ttl-seconds 0}})

list-collections clj

(list-collections client)

list-indexes clj

(list-indexes client collection)

rollback-tx clj

(rollback-tx client tx-id)

snapshot clj

(snapshot client)

Lazily stream the gzip-tar snapshot archive as a seq of byte arrays.

snapshot-to-file clj

(snapshot-to-file client path)

Stream a whole-database snapshot straight to path; returns bytes written.

stats clj

(stats client collection)

update-by-key clj

(update-by-key client collection key data)

update-if-rev clj

(update-if-rev client collection key expected-rev data)

Compare-and-swap on key, conditional on expected-rev. Returns {:swapped bool :record {...}|nil}; a stale rev (or missing key) is a no-op.

update-record clj

(update-record client
               collection
               id
               data
               &
               {:keys [ttl-seconds] :or {ttl-seconds 0}})

upsert clj

(upsert client collection key data)

watch clj

(watch client collection & {:keys [filter]})

Subscribe to change events on collection as a lazy seq of event maps. The seq blocks until the next event and runs until the stream ends. Opts: :filter.