> ## Documentation Index
> Fetch the complete documentation index at: https://docs.fga.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Modeling Google Drive permissions with Auth0 FGA

> Modeling Google Drive permissions

This tutorial explains how to represent [Google Drive](https://www.google.com/intl/en-GB/drive/) permissions model with [Auth0 FGA](https://docs.fga.dev/fga.md).

**What you will learn**

* Indicate [relationships](https://docs.fga.dev/fga-concepts.md#what-is-a-relationship) between a group of **[users](https://docs.fga.dev/fga-concepts.md#what-is-a-user)** and an **[object](https://docs.fga.dev/fga-concepts.md#what-is-an-object)**. See [Modeling User Groups](https://docs.fga.dev/modeling/basics/user-groups.md) for more.\

  Used here to indicate that all users within a domain can access a document (sharing a document within an organization).
* Model **concentric relationship** to have a certain [relation](https://docs.fga.dev/fga-concepts.md#what-is-a-relation) on an object imply another relation on the same object. See [Modeling Concepts: Concentric Relationships](https://docs.fga.dev/modeling/concepts/concentric-relationships.md) for more.\

  Used here is to indicate that writers are also commenters and viewers.
* Using [**the union operator**](https://docs.fga.dev/modeling/configuration-language.md#the-union-operator) condition to indicate that a user might have a certain relation with an object if they match any of the criteria indicated.\

  Used here to indicate that a user can be a viewer on a document, or can have the viewer relationship implied through commenter.
* Using the **[type bound public access](https://docs.fga.dev/fga-concepts.md#what-is-type-bound-public-access)** in a [relationship tuple's](https://docs.fga.dev/fga-concepts.md#what-is-a-relationship-tuple) user field to indicate that everyone has a certain relation with an object. See [Modeling Public Access](https://docs.fga.dev/modeling/basics/public-access.md) for more.\

  Used here to [share documents publicly](#04-sharing-files-and-folders-publicly).
* Model [**parent-child objects**](https://docs.fga.dev/modeling/basics/parent-child.md) to indicate that a user having a relationship with a certain object implies having a relationship with another object in Auth0 FGA.\

  Used here is to indicate that a writer on a folder is a writer on all documents inside that folder.

[Google Drive
Explore the Google Drive sample on the Auth0 FGA Playground](https://play.fga.dev/sandbox/?store=gdrive)

## Before you start

In order to understand this guide correctly you must be familiar with some Auth0 Fine-Grained Authorization (FGA) concepts and know how to develop the things that we will list below.

<details>
  <summary>
    ### Auth0 FGA concepts

    It would be helpful to have an understanding of some concepts of Auth0 FGA before you start.
  </summary>

  #### Modeling concentric relationships

  You need to know how to update the authorization model to allow having nested relations such as all writers are readers. [Learn more →](https://docs.fga.dev/modeling/concepts/concentric-relationships.md)

  #### Modeling object-to-object relationships

  You need to know how to create relationships between objects and how that might affect a user's relationships to those objects. [Learn more →](https://docs.fga.dev/modeling/concepts/object-to-object-relationships.md)

  Used here to indicate that users who have access to view a folder have access to view all documents inside it.

  #### Modeling public access

  You need to know how to add a relationship tuple to indicate that a resource is publicly available. [Learn more →](https://docs.fga.dev/modeling/basics/public-access.md)

  #### Concepts & configuration language

  * The [Auth0 FGA Concepts](https://docs.fga.dev/fga-concepts.md)
  * [Configuration Language](https://docs.fga.dev/modeling/configuration-language.md)
</details>

## What you will be modeling

Google Drive is a system to store, share, and collaborate on files and folders. [Source](https://www.google.com/drive/)

In this tutorial, you will build a subset of the Google Drive permission model (detailed below) in Auth0 Fine-Grained Authorization (FGA), using some scenarios to validate the model.

> Note: For brevity, this tutorial will not model all of Google Drive's permissions. Instead, it will focus on modeling for the scenarios outlined below

### Requirements

Google Drive's permission model is represented in [their documentation](https://developers.google.com/drive/api/v3/ref-roles).

In this tutorial, you will be focusing on a subset of these permissions.

Requirements:

* Users can be owners, editors, commenters and viewers of documents
* Documents can be shared with all users in a domain
* Folders can contain documents and users with a certain permission on a folder have that same permission to a document in that folder
* Documents and folders can be shared publicly

### Defined scenarios

There will be the following users:

* Anne, who is in the xyz domain
* Beth, who is in the xyz domain
* Charles, who is in the xyz domain
* Diane, who is NOT in the xyz domain
* Erik, who is NOT in the xyz domain

There will be:

* a 2021-budget document, owned by Anne, shared for commenting with Beth and viewable by all members of the xyz domain.
* a 2021-planning folder, viewable by Diane and contains the 2021-budget document
* a 2021-public-roadmap document, owned by Anne, available for members xyz domain to comment on and is publicly viewable

## Modeling Google Drive's permissions

### 01. Individual permissions

To keep thing simple and focus on Auth0 Fine-Grained Authorization (FGA) features rather than Google Drive complexity we will model only four [roles](https://developers.google.com/drive/api/v3/ref-roles) (Viewer, Commenter, Writer, Owner).

At the end of this section we want to have the following permissions represented:

![Image showing permissions](https://mintlify.s3.us-west-1.amazonaws.com/auth0-fga/images/fga/docs/content/modeling/advanced/assets/gdrive-gdrive1.svg)

To represent permissions in Auth0 FGA we use [relations](https://docs.fga.dev/fga-concepts.md#what-is-a-relation). For document permissions we need to create the following [authorization model](https://docs.fga.dev/fga-concepts.md#what-is-an-authorization-model):

The Auth0 Fine-Grained Authorization (FGA) service determines if a [user](https://docs.fga.dev/fga-concepts.md#what-is-a-user) has access to an [object](https://docs.fga.dev/fga-concepts.md#what-is-an-object) by [checking](https://docs.fga.dev/fga-concepts.md#what-is-a-check-request) if the user has a relation to that object. Let us examine one of those relations in detail:

> [!NOTE]
>
> The snippet above indicates that objects of type document have users related to them as "viewer" if those users belong to the userset of all users related to the document as "viewer".
>
> This means that a user can be [directly related](https://docs.fga.dev/fga-concepts.md#what-are-direct-and-implied-relationships) as a viewer to an object of type "document"

If we want to say `beth` is a commenter of **document:2021-budget** we create this relationship tuple:

We can now ask Auth0 FGA "is `beth` a commenter of repository **document:2021-budget**?"

We could also say that `anne` is an owner of the same document:

And [ask](https://docs.fga.dev/fga-concepts.md#what-is-a-check-request) some questions to Auth0 FGA:

The first reply makes sense but the second one does not. Intuitively, if `anne` was an **owner**, she was also be a **writer**. In fact, Google Drive explains this in [their documentation](https://developers.google.com/drive/api/v3/ref-roles)

![Image showing roles](https://mintlify.s3.us-west-1.amazonaws.com/auth0-fga/images/fga/docs/content/modeling/advanced/assets/gdrive-roles.svg)

To make Auth0 FGA aware of this "concentric" permission model we need to update our definitions:

> [!NOTE]
>
> Let's examine one of those relations in detail:
>
> objects of type document have users related to them as "viewer": if they belong to any of (the union of) the following:
>
> * the userset of all users related to the document as "viewer"
> * the userset of all users related to the document as "commenter"

With this update our model now supports nested definitions and now:

### 02. Organization permissions

Google Drive allows you to share a file with everyone in your organization as a viewer, commenter or writer/editor.

![](https://mintlify.s3.us-west-1.amazonaws.com/auth0-fga/images/fga/docs/content/modeling/advanced/assets/gdrive-org.svg)

At the end of this section we want to end up with the following permissions represented:

![Image showing permissions](https://mintlify.s3.us-west-1.amazonaws.com/auth0-fga/images/fga/docs/content/modeling/advanced/assets/gdrive-gdrive2.svg)

To add support for domains and members all we need to do is add this object to the [Auth0 FGA](https://docs.fga.dev/fga.md) [authorization model](https://docs.fga.dev/fga-concepts.md#what-is-a-type-definition). In addition, update the model to allow domain member to be assigned to document:

> [!NOTE]
>
> Objects of type "domain" have users related to them as "member" if they belong to the userset of all users related to the domain as "member".
>
> In other words, users can be direct members of a domain.

Let's now create a domain, add members to it and make all members **viewers** of **document:2021-budget**.

The last relationship tuple introduces a new **Auth0 FGA** concept. A **[userset](https://docs.fga.dev/fga-concepts.md#what-is-a-user)**. When the value of a user is formatted like this **objectType:objectId#relation**, Auth0 Fine-Grained Authorization (FGA) will automatically expand the userset into all its individual user identifiers:

### 03. Folder permission propagation

[Permission propagation](https://developers.google.com/drive/api/v3/manage-sharing#permission_propagation) happens between folders and files: if you are a viewer in a folder, you can view its documents. This applies even when you are not explicitly a viewer in a document.
![Image](https://pbs.twimg.com/media/Eme_FlYW4AEAYfi?format=jpg\&name=large)

At the end of this section we want to end up with the following permissions represented. Note that a folder is an object in the **document** type, as we do not need a separate type:

![Image showing permissions](https://mintlify.s3.us-west-1.amazonaws.com/auth0-fga/images/fga/docs/content/modeling/advanced/assets/gdrive-gdrive3.svg)

We need to add the notion that a **document** can be the **parent** of another **document**. We know how to do that:

> [!NOTE]
>
> Notice the newly added "parent" relation in the configuration above.

We can indicate this relation by adding the following relationship tuples

What we still lack is the ability to propagate permissions from parent to children. We want to say that a user is a viewer of a document if either:

* \[done] they have a viewer relationship (directly or through domain membership)
* \[pending] they have a viewer relationship with the parent document

We need a way to consider the parent viewers, not just direct viewers of the document when getting a check for:

More details on this technique can be found in the section [Modeling Parent-Child Objects](https://docs.fga.dev/modeling/basics/parent-child.md).

We express it like this:

> [!NOTE]
>
> The users with a viewer relationship to a certain object of type "document" are any of:
>
> * the "viewers": the set of users who are [directly related](https://docs.fga.dev/fga-concepts.md#what-are-direct-and-implied-relationships) to the document as a "viewer"
> * the "commenters": the set of users who are related to the object as "commenter"
> * the "viewers of the parents": from the objects who are related to the doc as parent, return the sets of users who are related to those objects as "viewer"
>
> What the added section is doing is:
>
> 1. read all relationship tuples related to document:2021-budget as parent which returns:
>
> `[{ "object": "document:2021-budget", "relation": "parent", "user": "document:2021-planning" }]`
>
> 2. for each relationship tuple read, return all usersets that match the following, returning tuples of shape:
>
> `{ "object": "document:2021-planning", "viewer", "user": ??? }`
>
> including: `{ "object": "document:2021-planning", "viewer", "user": "user:diane" }`

The updated authorization model looks like this:

### 04. Sharing files and folders publicly

Google Drive has a feature which allows [sharing a file or folder publicly](https://support.google.com/a/users/answer/9308873?hl=en), and specifying the permissions a public user might have (writer/commenter/viewer).

Assume that `Anne` has created a new document: `2021-public-roadmap`, has shared it with commenter permissions to the `xyz.com`, and has shared it as view only with the public at large.

![Image showing requirements](https://mintlify.s3.us-west-1.amazonaws.com/auth0-fga/images/fga/docs/content/modeling/advanced/assets/gdrive-gdrive4.svg)

Here's where another Auth0 Fine-Grained Authorization (FGA) feature, [type bound public access](https://docs.fga.dev/fga-concepts.md#what-is-type-bound-public-access) (as in everyone), would come in handy.

First, we will need to update our model to allow for public access with type `user` for viewer relation.

To mark Anne as the owner, the domain members as commenters and the public as viewers, we need to add the following relationship tuples:

Anne is an owner of the document

Beth is a member of the xyz.com domain, and so can comment but cannot write

Erik is NOT a member of the xyz.com domain, and so can only view the document

[Google Drive
Explore the Google Drive sample on the Auth0 FGA Playground](https://play.fga.dev/sandbox/?store=gdrive)

## Related Sections

Take a look at the following sections for more information.

[Search with permissions
Give your users search results with objects that they have access to](https://docs.fga.dev/integration/advanced/search-with-permissions.md)