synthigy.client.files — com.synthigy/sdk 0.2.4

clj

Files: the bytes behind /files, each also a File record on /data.

(require '[synthigy.client.files :as files])

(files/folder "/site/img/") ; the folder, and any missing above it (def f (files/put "/site/img/logo.png" (io/file "logo.png"))) ; again: a new version (files/download "/site/img/logo.png") ; bytes; :as :stream :text (files/move f "/site/brand/")

A file is a path (/a/b/name), an xid or the file itself; a folder is a path ending in /, an xid or the folder itself. Response keys follow the client's :key-format, as /data results do: kebab-case by default.

cljs

Files: the bytes behind /files, each also a File record on /data. Every call returns a Promise.

(require '[synthigy.client.files :as files])

(p/let [_ (files/folder "/site/img/") ; the folder, and any missing above it f (files/put "/site/img/logo.png" blob) ; creates it; again: a new version bytes (files/download "/site/img/logo.png")] ; Uint8Array; :as :blob :text … (files/move f "/site/brand/"))

A file is a path (/a/b/name), an xid or the file itself; a folder is a path ending in /, an xid or the folder itself. Response keys follow the client's :key-format, as /data results do: kebab-case by default.

access clj/s

(access folder)

Who holds read, write and delete on folder.

blob? cljs

(blob? x)

body+type clj/s≠

(body+type data content-type)

clj

Bytes to send and their content type; a stream is read into memory so the 401 retry can resend it.

cljs

Body to send and its content type.

cased clj/s

(cased u)

u with the client's key format as ?key_format=, unless it is snake or unset.

delete clj/s

(delete ref)

Delete a file, or an empty folder (a path ending in /, or the folder itself).

download clj/s≠

(download ref & {:keys [as range version if-none-match] :or {as :bytes}})

clj

The bytes of file ref, or nil while :if-none-match still matches. Options: :as (:bytes default, :text, :stream to close yourself) :range [start end] (inclusive, nil leaves a side open) :version :if-none-match

cljs

The bytes of file ref, or nil while :if-none-match still matches. Options: :as (:bytes default, :blob :text :array-buffer :stream :response) :range [start end] (inclusive, nil leaves a side open) :version :if-none-match

enc clj/s

(enc x)

enc-part clj/s

(enc-part s)

One path segment percent-encoded but for RFC 3986 unreserved characters, as the server builds links.

endpoint-url clj/s

(endpoint-url path query)

file-at clj/s

(file-at ref)

(file-at ref tail)

Path and query of one file: /<xid><tail>, or <tail>?path= for a path.

file-ref clj/s

(file-ref x)

folder clj/s

(folder path)

(folder path settings)

The folder at path, made with every missing folder above it; settings {:public :cache :can-link} sets its own values (nil inherits).

folder-at clj/s

(folder-at ref)

(folder-at ref tail)

Path and query of one folder: /folders/<xid><tail>, or /folders<tail>?path= for a path.

folder-ref clj/s

(folder-ref x)

folder? clj/s

(folder? x)

grantees clj/s

(grantees {:keys [users groups]})

holds-words? clj/s

(holds-words? q s)

Whether s holds the words of q in order, ignoring case.

info clj/s

(info ref)

File ref, or nil when it is not there or you cannot see it.

json-call clj/s

(json-call method path)

(json-call method path payload)

(json-call method path payload query)

kebab clj/s

(kebab data)

link clj/s

(link ref & {:as opts})

A link that downloads file ref without signing in, where its folder allows links; its :url is shown only now. Options: :expires (seconds, default 3600, at most 7 days) :max-downloads :inline

link-body clj/s

(link-body {:keys [expires max-downloads inline]})

links clj/s

(links ref)

The live links of file ref you can see: your own, or all of them for File Admin.

list clj/s

(list)

(list folder & {:keys [q limit offset]})

{:files :folders}: a folder's files and subfolders; nil is the files in no folder, :all (or no folder) every file you can see, newest first. Options: :q :limit :offset

move clj/s

(move from to)

Rename or move: a file goes to to (/a/new.png), or into a folder when to ends in / (the name stays); a folder's to is its new path.

move-body clj/s

(move-body from to)

PATCH body for moving from to path to.

object-url cljs

(object-url ref)

Browser: download with your token into a blob: URL for <img> or <iframe>: {:url :revoke}.

parse-json cljs

(parse-json text)

path? clj/s

(path? x)

put clj/s

(put target data & {:keys [content-type if-match]})

Store bytes: a path (/a/b/name, the folder must exist) creates or replaces that file, an xid or the file replaces it, {:name n} makes a new file in no folder. Options: :content-type :if-match (a hash, or the file)

refusal clj/s≠

clj

(refusal {:keys [status body headers]})

cljs

(refusal {:keys [status body-text headers]})

The ex-info for a refused /files call.

restore clj/s

(restore ref version)

Make kept version (its :id, or the version) of file ref current again; no bytes are copied.

search clj/s

(search q & {:keys [folder limit offset]})

Folders and files whose paths hold the words of q in order, shortest first: {:results :truncated}, each result with :type. Options: :folder :limit :offset

seg clj/s

(seg x)

send! clj/s

(send! method u opts)

serve clj/s≠

(serve ref request & {:keys [inline]})

clj

Ring: answer request with file ref as a ring response (body an InputStream); Range and If-None-Match pass through, a refusal is the engine's own answer. Option :inline

cljs

Server: answer a browser's js/Request (or {:method :headers}) with file ref as a js/Response; Range and If-None-Match pass through, a refusal is the engine's own answer. Option :inline

served-headers clj/s

shape clj/s≠

clj

(shape data)

cljs

(shape client data)

share clj/s

(share folder access to)

Give {:users :groups} (xids or records) access (read, write or delete) on folder; writers of the folder may.

unlink clj/s

(unlink link)

End link (the link or its xid) at once, on every engine.

unshare clj/s

(unshare folder access from)

Take access on folder away from {:users :groups}.

url clj/s

(url ref & {:keys [inline]})

Where file ref loads from, without a request: /files/<xid>, or /files/path/… for a path. Option :inline opens it in the browser instead.

version-id clj/s

(version-id v)

versions clj/s

(versions ref)

The kept versions of file ref (the last ten), newest first.

xid-at clj/s≠

(xid-at ref)

clj

The xid of file ref; a path costs one info call.

cljs

Promise of the xid of file ref; a path costs one info call.

xid-of clj/s

(xid-of x)

zip clj/s≠

(zip & {:keys [files folders as] :or {as :bytes}})

clj

One zip of :files and of everything inside :folders (xids, paths or maps), read as you; what you cannot read is listed in its _skipped.txt. :as :bytes (default) or :stream to close yourself.

cljs

One zip of :files and of everything inside :folders (xids, paths or maps), read as you; what you cannot read is listed in its _skipped.txt. :as as in download (:bytes default).