///|
pub(all) enum Role {
Viewer
Editor
Owner
}
///|
pub struct DocShare {
priv model : @fga.AuthModel
priv tuples : @store.MemoryStore
priv engine : @engine.Engine
}
///|
pub fn model_source() -> String {
let source =
#|model
#| schema 1.1
#|
#|type user
#|
#|type group
#| relations
#| define member: [user]
#|
#|type folder
#| relations
#| define owner: [user]
#| define editor: [user, group#member] or owner
#| define viewer: [user, group#member] or editor
#|
#|type document
#| relations
#| define parent: [folder]
#| define owner: [user]
#| define editor: [user, group#member] or owner or editor from parent
#| define viewer: [user, group#member, user with before_expiry] or editor or viewer from parent
#|
#|condition before_expiry(now: timestamp, expires_at: timestamp) {
#| now < expires_at
#|}
source
}
///|
fn invalid(message : String) -> @fga.FgaError {
@fga.fail(@fga.ERR_VALIDATION, message)
}
///|
fn validate_tuple(
model : @fga.AuthModel,
tuple : @fga.Tuple,
) -> Unit raise @fga.FgaError {
if !@fga.is_valid_object(tuple.object) || !@fga.is_valid_user(tuple.user) {
raise invalid("invalid object or subject")
}
let restrictions = model.direct_restrictions(
@fga.object_type(tuple.object),
tuple.relation,
)
let matching = restrictions.filter(fn(restriction) {
restriction.condition == tuple.condition_name()
})
if !@fga.restrictions_allow(matching, tuple.user) {
raise invalid("tuple is not allowed by the document-sharing model")
}
}
///|
/// Input is a JSON array of MoonFGA tuple objects, with optional conditions.
pub fn DocShare::from_json(source : String) -> DocShare raise @fga.FgaError {
let json = @json.parse(source) catch {
_ => raise invalid("invalid tuples JSON")
}
guard json is Array(_) else { raise invalid("tuples must be a JSON array") }
let model = @dsl.parse_model(model_source())
@validate.validate_or_fail(model)
let tuples = @fga.tuples_from_json(Some(json))
for tuple in tuples {
validate_tuple(model, tuple)
}
let store = @store.MemoryStore::new()
let _ = store.write_all(tuples)
{
model,
tuples: store,
engine: @engine.Engine::new(model, store as &@fga.TupleReader),
}
}
///|
pub fn DocShare::new() -> DocShare raise @fga.FgaError {
DocShare::from_json("[]")
}
///|
/// Trusted provisioning operation; the caller must authorize mutations.
pub fn DocShare::share_document(
self : DocShare,
document : String,
subject : String,
role : Role,
) -> Bool raise @fga.FgaError {
if @fga.object_type(document) != "document" {
raise invalid("expected a document object")
}
let tuple = @fga.Tuple::{
object: document,
relation: match role {
Viewer => "viewer"
Editor => "editor"
Owner => "owner"
},
user: subject,
condition: None,
}
validate_tuple(self.model, tuple)
self.tuples.write(tuple)
}
///|
fn request_context(now : String) -> Map[String, @json.Json] {
Map([("now", @json.Json::string(now))])
}
///|
/// `now` must come from a trusted host clock in a real service.
pub fn DocShare::can_view(
self : DocShare,
user : String,
document : String,
now : String,
) -> Bool raise @fga.FgaError {
self.engine.check_with(document, "viewer", user, request_context(now), [])
}
///|
pub fn DocShare::can_edit(
self : DocShare,
user : String,
document : String,
) -> Bool raise @fga.FgaError {
self.engine.check(document, "editor", user)
}
///|
pub fn DocShare::list_viewable_documents(
self : DocShare,
user : String,
now : String,
) -> Array[String] raise @fga.FgaError {
let documents = self.engine.list_objects(
"document",
"viewer",
user,
request_context(now),
[],
)
documents.sort_by(String::lexical_compare)
documents
}