Store function as value in document

[Mike]

Making it possible to store directly the reference to a function or the function itself as a part of the value in a document

{
  cmsFunction: Function.byName("activate_numberOfShareholdersQuestions")
}

or

{
  sell: (document) => {}
}

Fauna passes the reference to the document automatically to the function if the function includes the parameter “document” (like in ABAC)

(document) => {
 // activate_numberOfShareholdersQuestions
}

Use Case 1:

We have CMS(Content management system) functions specific to single documents. With that change it would become easier working with functions in the context of documents.

Instead of doing this as today:

Document (Collection Answer)

{
  cmsFunction:"activate_numberOfShareholdersQuestions"
}

Function activate_numberOfShareholdersQuestions

() => {
  let document = Answer.byId("56546545546456564") // hardcoded reference to the connected document
  
}

Client

let cmsFunction = Function.byName(Answer.byId("56546545546456564").cmsFunction)

We could simplify it like that

Document (Collection Answer)

{
  cmsFunction: Function.byName("activate_numberOfShareholdersQuestions")
}

Function activate_numberOfShareholdersQuestions

(document ) => {
  // no hardcoded reference needed  
}

Client

Answer.byId("56546545546456564").cmsFunction()

Use Case 2

Scoped Functions - Keeps functions organized and structured in a scaled environment.

e.g.

Car.byId("34223424").sell()

Car.sell()

[ptpaterson]

Are you trying to store arbitrary lambdas, or do you want the document to be passed in as a hidden “self” argument? I think the two would be very different implementations.

For example, maybe we could allow instance methods to be defined on the Collection itself, rather than store lambdas in each document. what do you think about that?

If we permit storing lambda in a document field, it likely wouldn’t have any special access to the document. I don’t think we want to get into Javascript this territory especially if we are able to defined methods on the Collection.

[Mike]

The 2nd one (passing the document as a “self” argument). And inside, making it possible to call arbitrary lambdas if needed. I think with that, we get the best of both worlds.

(document) => {
 callArbitraryFunction()
}

[ptpaterson]

The response I left here may also be relevant: Domains/Namespaces

@ptpaterson

Namespacing of sorts is on the roadmap. Like you say, once your application grows managing a lot of schema definitely gross complex. And we definitely encourage you to put a lot of business logic into Fauna, given the power of FQL, permissions etc.

As a workaround, I wonder if this would work for you for now:

You can create a UDF which is a “constructor” of sorts.

// FSL
function User(id) {
  let doc = _user.byId(id)!

  {
    impersonate: (other) => User_impersonate(doc, other),
    doc: () => doc,
    update: (params) => doc.update(params),
    delete: () => doc.delete(),
  }
}

function Car(id) {
  let doc = _car.byId(id)!

  {
    sell: (user) => Car_sell(doc, user),
    doc: () => doc,
    update: (params) => doc.update(params),
    delete: () => doc.delete()
  }
}

@role(fnUser_impersonate)
function User_impersonate(user, other) { /* ... */ }

@role(fnCar_sell)
function Car_sell(car, user) { /* ... */ }

// If the above terms are how you want to interact with the data, then name the collections something different.
collection _user {}
collection _car {}

// define those roles as well

This may be a bit contrived, but I hope it illustrates how you encapsulate logic into objects.