ben-dechrai

A technologist with a staunch focus on security and privacy. I love helping developers find the joy of experimentation, and designing unconventional solutions for the purposes of learning something new.

Developer Advocate

Ben Dechrai

You’ve probably heard by now that [Okta and Auth0 have joined forces](https://auth0.com/blog/developers-explore-okta-auth0/). As a developer advocate for Auth0, I’m really excited to see how we can combine our forces to make identity even better for the developer community.

You might not be aware that I’m a huge fan of creating events that directly address the needs of developer communities. From the first conference I ran in 2004 to the user group meetings that are still going to this day, you can imagine my excitement when I heard we (Auth0 and Okta) were going to run an online event together!

This time, members of my team are taking the lead, so I'll be in the same boat as many of you experiencing Developer Day as it happens, so I thought it might be helpful to share my thoughts on the event and what I’m looking forward to the most.

Hit up the [community forum](http://community.auth0.com/) if I miss something that’s important to you &mdash; there’s so much for everyone, I’m sure you’ll help others out too.

## What Is Developer Day?

[Developer Day](https://www.okta.com/developerday/) creates a space for all developers to discover how the identity space is evolving, learn best practices in privacy and security, and gain insights from developer experiences. It brings speakers from across these sectors right to your desktop, and best of all &mdash; it’s free!

> Speaking of free, did you know you can also <a href="https://auth0.com/signup" data-amp-replace="CLIENT_ID" data-amp-addparams="anonId=CLIENT_ID(cid-scope-cookie-fallback-name)">sign up for a free Auth0 account</a> at any time? Why not try it out today?

![Developer Day speakers Cassidy Williams, Alyssa Miller, and Kapehe](https://images.ctfassets.net/23aumh6u8s0i/12g1Ga4gP8X04Xn0H0nnFt/5b4ae4b06847a028d9a784a46ec48b26/cassidy-alyssa-kapehe.png)

More specifically, it’s a one-day, single-track, virtual event, and while I’m proud to see some of my colleagues’ names in the speaker list, the lineup also features the likes of **Cassidy Williams** (Director of Developer Experience at Netlify), **Alyssa Miller** (Hacker, Researcher, and Security Advocate), and **Kapehe** (Developer Relations at Sanity.io, and yes, you might remember she used to [work at Auth0](https://auth0.com/blog/authors/kapehe-jorgenson/) too).

## What Can I Learn?

The first place I tend to go when looking at an event is the agenda, and skimming over this one, we’re in for a breadth and depth of information.

The keynote is where the day’s journey starts, and Alyssa’s **updates from the world of cyber security** are sure to offer a great insight that sets the foundation for the day. I’m a huge advocate for helping all developers understand security principles and states of play. Even if you never have to deal with part of it yourself, you’ll always benefit from knowing why something is done and how you’re being protected.

## From APIs to IoT: Live Demos and Security Fundamentals

From there, we meander down a path from securing Python APIs to securing your Home Automation and IoT devices. Personally, I’m a sucker for anything IoT-related, so I’ll be paying attention to this one.

![Developer Day speakers Aaron Parecki and Vittorio Bertocci](https://images.ctfassets.net/23aumh6u8s0i/hd4kE3aQJFlX45nvwu3xF/6496580a2a7c7da50a6591f781035097/aaron-vittorio.png)

Having grown up on YouTube videos (okay, I’m not that young...) about identity from both Aaron Parecki (or as I like to call him, Mr OAuth, but don’t tell him I told you) and Vittorio Bertocci (the man whose identity knowledge is dwarfed only by his magnificent hair), what better than a talk from both of them? The talk will not only cover where we’ve come from, but what the future of OAuth has in store for us.

## Advanced Topics like Verifiable Credentials and Integration with Third Parties

But identity isn’t just about logging in and loading your glamour shot from Gravatar. I just recently learned about verifiable credentials, and wow - it’s such a powerful concept with so many use cases, I just can’t even! The topic deserves its own article, but one example is around payments, and Uchi Uchibeke’s talk is going to be fascinating, to be sure.

![Developer Day speaker Uchi Uchibeke](https://images.ctfassets.net/23aumh6u8s0i/71FxWB7JqseFrDM9mF63Go/bd98bfcda1f9662b1c7de0bfab486599/uchi.png)

Uchi is flanked by demos on integrating Auth0 with NextJS for securing your webapps and Okta with Kong for securing continuous integration, delivery, and deployment. I think this highlights that the team who worked on the agenda really put a lot of thought into the balance between talks that can have immediate benefit to us developers, as well as enough advanced topics to keep our creative juices flowing.

Talking of immediately applicable information, if you want to learn how to validate REST API authentication and authorization, the JFrog talk is for you.

## Authentication in Gaming and Extended Realities

If you thought the IoT talk was a bit out of the box, the Gaming and XR talk might just be in a whole other room! Not literally. I mean &mdash; it’s a virtual event. There aren’t any rooms. There aren’t any boxes either, for that matter. I digress.

I won’t admit to being a huge gamer. I load up Poly Bridge 2 every now and then. Does Minesweeper count? One thing I do know, though, is that the authentication experience in games can be awful, and when you get into any extended reality (XR), well. Let’s not go there.

![Developer Day speaker Nick Gamb](https://images.ctfassets.net/23aumh6u8s0i/2REEADn8ARvYmok2WNAt5O/9185928ac397dced701f3cb2d252e4b9/nick.png)

We’ll let Okta's Nick Gamb go there instead, as he tells us about the propensity for this industry to be targeted by hackers. Follow his advice, and maybe we can all keep playing in the knowledge that our Minedimes are safe. (See &mdash; I told you I’m not a huge gamer.)

## Adding Pixie Dust to Enhance Security

![Developer Day speaker Milecia McGregor](https://images.ctfassets.net/23aumh6u8s0i/2tBAGZHtBlb4Dt1P21WzAS/2cd4c6438265b64c39bb39b89e6945b9/milecia.png)

With two talks left for the day, I’m personally keen to catch Milecia McGregor from Mediavine talk about pixies! Stop it, autocorrect. PKCE! While most SDKs magically hide away much of the implementation, it’s still worth understanding how authentication flows work and how they can be improved. The most common OAuth flow is debatably the Authcode flow, but PKCE makes it even better! Come along to find out how. I’ll be at the front taking notes.

## Closing Keynote

It’s a packed event &mdash; thank goodness there are a couple of breaks during the day &mdash; and we finish with a closing keynote from Cassidy Williams. The agenda teases us with the mere existence of this session, and perhaps we’ll find out more before the event. In any case, I’ll not be missing it.

Tell us in the [community forum](http://community.auth0.com/) what you’re looking forward to the most, and I hope to see some of you in the chat room on the day!

Developer Day Helps Developers Build the Future of Identity

We're excited to announce the **general availability of [Actions](https://auth0.com/docs/actions)**, which simplifies your custom workflows for **extending** Auth0 and offers an improved developer experience from Rules and Hooks!


<NonAmpContent>
<div class="embed-container" style="position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden; max-width: 100%;margin-bottom:40px;"><iframe style="position: absolute; top: 0; left: 0; width: 100%; height: 100%;" src='https://www.youtube.com/embed/UesFSY1klrI' frameborder='0' allowfullscreen></iframe></div>
</NonAmpContent>

<AmpContent>
  <amp-iframe width="480" height="270"
    sandbox="allow-scripts allow-same-origin"
    layout="responsive"
    frameborder="0"
    src="https://www.youtube.com/embed/UesFSY1klrI">
  </amp-iframe>
</AmpContent>

## What Is Actions?

One of the core capabilities that Auth0 brings you is the power of **serverless extensibility**.

You might have used [Rules](https://auth0.com/docs/rules/) already to execute custom code after your users log in, or [Hooks](https://auth0.com/docs/hooks) which offer similar functionality around certain other extensibility points. If you have, you'll be forgiven for trying to remember which area to use for what purposes, or wonder why the experience of each is so different.

This is where [Actions](https://auth0.com/docs/actions) comes in.

> Auth0 Actions provides a unified view across secure, tenant-specific, self-contained functions that allow you to customize the behavior of Auth0. Each action is bound to a specific triggering event on the Auth0 platform, which executes custom code when that event is produced at runtime.

## Rules and Hooks Got Us Here

Rules are a really powerful feature of Auth0 and are possibly one of the biggest reasons we stand out from the crowd. They allow you to run custom code after the user logs in and before your tenant hands them back to your application. Being able to augment claims in ID and Access Tokens, call external APIs, or control MFA processes, to name just a few examples, is a game-changer for many.

If you've used them extensively, we're sure you've experienced some limitations.

For starters, we keep a curated list of around 2,000 npm packages that you can use in your scripts. Keeping the list up-to-date and adding new packages is constant work for us and frustration for you.

And a newly saved rule is immediately active, affecting the next user to log in - there's no easy way to test it before this time.

Hooks was our first attempt to improve the experience. The main difference was an improved code editor, and the ability to search for npm packages available in the curated list. You also got access to a more integrated code testing interface with direct access to logs.

By focusing on events outside of the authentication workflow, Hooks added five extensibility points you could tap into:

- Client Credentials Exchange,
- Post Change Password,
- Post User Registration,
- Pre User Registration, and
- Send Phone Message

There are still a few disadvantages, though. Each hook can only have one active script, and you still have the issue of needing to make custom code live to test it.

And of course, now your custom code is split between two locations in the dashboard.

Further, neither Rules nor Hooks have version history. While this is easily solved by using the [Deploy Command-Line Interface (CLI) Tool](https://auth0.com/docs/deploy/deploy-cli-tool), we wanted to provide this ability directly in the dashboard.

## The Difference with Actions

Compare Rules and Hooks with the benefits of Actions, and it's clear this is a major evolution.

![Extensibility Feature Comparison](https://images.ctfassets.net/kbkgmx9upatd/2AtB5N5Y44fftQrQPkt1e6/79b0c00e3f96455ea96f3276fb2dc67e/extensibility-feature-comparison-v2.png)

Actions unites and improves on Rules and Hooks and you'll find everything you need in the two menu items under the Actions header in the dashboard navigation: Flows, and Custom Actions.

Flows is where you can configure the workflows, with the six events you had access to before now available through six triggers (and a potential for more to be added):

![Flows Screen](https://images.ctfassets.net/23aumh6u8s0i/6K2dRDVqbcmqiNMV98IpQO/8dcd45c02d9153924c1cc069529cfc8a/flows.png)

The Custom Actions section provides a common and consistent coding interface that provides all the functionality you need to create your custom functions.

> It's important to remember that Rules and Hooks are still available and will execute before their counterparts in Actions.

### A New Editor

There are many benefits you'll enjoy from Actions, not least being the usefulness of the code editor. We've added contextual assistance and inline docs, so you'll be prompted with suggestions as you type. Whereas you were previously much more reliant on the documentation for Rules and Hooks, you should find development time drops!

<img src="https://tinygif.com/images/2021/05/10/editor-writing.gif" alt="editor-writing.gif" border="0" />
<p align="center">Contextual assistance and inline docs in the new code editor</p>


And when you're ready to test your script, you can save it as a draft and test it right on that screen. You'll get feedback before you even deploy the functions: faster development and more confidence. You'll be nailing this in no time.

<img src="https://tinygif.com/images/2021/05/10/editor-testing.gif" alt="editor-testing.gif" border="0" />
<p align="center">In-editor testing interface</p>

### Consistent Function Signatures

> This is our third-generation extensibility platform, built from the ground up. We've developed a new programming model, which means the underlying objects, data, and APIs available to you in the custom actions are now consistent across each action type. We couldn’t have done this without all the feedback we've received from you since we moved Actions into Beta, so a massive thanks to you!

Each custom action you create will include boilerplate code with a function that gets called when executed. All of these functions will receive an `event` object as their first parameter: a read-only object containing all the inputs and context about this event.

The Post Login, Machine to Machine, and Pre User Registration triggers will also receive an `api` object containing all the outcomes that can take place. Think of this as an encapsulation of the side-effects you are able to perform by modifying the context object used in Rules and Hooks, refactored into documented function calls.

<table border="1">
  <tr bgcolor="lightgrey">
    <th>Capabilities in the <code>api</code> object</th>
    <th style="text-align:center">Post Login </th>
    <th style="text-align:center">Machine toMachine </th>
    <th style="text-align:center">Pre User Registration</th>
  </tr>
  <tr>
    <td>Deny User Access</td>
    <td style="text-align:center">✅</td>
    <td style="text-align:center">✅</td>
    <td style="text-align:center">✅</td>
  </tr>
  <tr>
    <td>Add claims to Access and ID Tokens</td>
    <td style="text-align:center">✅</td>
    <td style="text-align:center">✅</td>
    <td style="text-align:center"></td>
  </tr>
  <tr>
    <td>Set <code>user_metadata</code> and <code>app_metadata</code></td>
    <td style="text-align:center">✅</td>
    <td style="text-align:center"></td>
    <td style="text-align:center">✅</td>
  </tr>
  <tr>
    <td>Conditionally enable multi-factor authentication</td>
    <td style="text-align:center">✅</td>
    <td style="text-align:center"></td>
    <td style="text-align:center"></td>
  </tr>
  <tr>
    <td>Redirect users</td>
    <td style="text-align:center">✅</td>
    <td style="text-align:center"></td>
    <td style="text-align:center"></td>
  </tr>
</table>
<p style="text-align:center;font-style:italic">Operations available in the <code>api</code> object are dependent on the event triggered</p>

You'll notice in the table above that the Post Login trigger can perform a redirect during the authentication flow. Previously, after a redirect to another website during the login flow, the user would be redirected back to your tenant and all the rules and hooks would execute again.

Instead, Actions streamlines the process of getting the user back into the workflow for this trigger by introducing an `onContinuePostLogin` function. When the user returns from a redirect, the Post Login auth flow picks up from where it left off, and you no longer need to ensure idempotency manually.

Here's what a Post Login Action looks like, compared to the single function of a Rule.

![The difference between the Rules and Actions editors](https://images.ctfassets.net/23aumh6u8s0i/2qYhTtK7IgTJqR28pamsOP/4b242867f1d24a5db216ea66b7392c59/rules-v-actions.png)

### Modules, Secrets, and Version Control

Just like Hooks, Actions allows you to define secrets that can be accessed from your custom code, but now you can include **over 1,000,000 npm packages** in your script. That's right, you can now specify any package and even the version from the npm index, so long as there are no native bindings or C modules that need to be built.

<img src="https://tinygif.com/images/2021/05/10/editor-modules.gif" alt="editor-modules.gif" border="0" />
<p align="center">Adding one of 1,000,000 npm modules to an action</p>

And last but not least, you now have version control, allowing you to revert to any previously deployed version of the custom script.

### Adding Deployed Actions to Flows

When you have your first deployed Action, you're going to have to add it to one of the Flows. Selecting "Login" from the Actions > Flow screen will show you the login flow, at which point you can drag your Actions from the right-hand pane into that flow. Arrange multiple Actions as desired, click the "Apply" button, and you're set!

<img src="https://tinygif.com/images/2021/05/10/flow-editor.gif" alt="flow-editor.gif" border="0" />
<p align="center">Adding an Action to a Flow is a simple as drag-and-drop</p>

### Debugging and Management

We've touched on testing before making custom code live, but once your Actions are in use, you'll be glad to know the tenant logs will now include Actions-related details where applicable. Any log entry that is associated with an Action will now include an "Action Details" area, which shows not only any generated output, you'll also get some itemized stats on how long it took to execute the Action.

Naturally, as with everything else in your tenant, the things you can do through the dashboard can also be done through the [Management API](https://auth0.com/docs/api), via the [Management API SDK Libraries](https://auth0.com/docs/libraries#mgmt), and the [Deploy Command-Line Interface (CLI) Tool](https://auth0.com/docs/deploy/deploy-cli-tool).

## What's Next?

We're so excited to get Auth0 Actions into everyone's hands - we'd love to hear what you think. Be sure to comment below with your thoughts or questions.

This is just the beginning of Auth0 Actions. There's so much more to come, and we can't wait to see where we can take it with your feedback!

<include src="asides/AboutAuth0" />

Auth0 Actions Is Now Generally Available



Configuring MongoDB as an Auth0 custom database can simplify your user migration process, or even just add an OAuth and OpenID Connect layer on top of your existing database of users. Whatever your reason, let's step through the process of connecting Auth0 to MongoDB.

<div style="text-align: center; font-style: italic">This article is also available in video format</div>
<AmpContent>
<amp-youtube
    data-videoid="TXnDFU4sG0A"
    layout="responsive"
    width="480" height="270">
</amp-youtube>

</AmpContent>

<NonAmpContent>

<iframe width="560" height="315" src="https://www.youtube.com/embed/TXnDFU4sG0A" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

</NonAmpContent>

## Enabling Custom Databases

Don't already have an Auth0 account yet? <a href="https://a0.to/blog_signup" data-amp-replace="CLIENT_ID" data-amp-addparams="anonId=CLIENT_ID(cid-scope-cookie-fallback-name)">**Sign up for free today!**</a>

<include src="SignupCTA" text="Try out the most powerful authentication platform for free." linkText="Get started →" />

Once you're logged in, head to the [Database Connections](https://manage.auth0.com/#/connections/database) page, and click on the **Create DB Connection** button.

Give this database configuration a meaningful name, click the **Create** button, and then switch to the **Custom Database** tab.

![Creating a new Custom Database in Auth0](https://images.ctfassets.net/23aumh6u8s0i/496MewuOZuw98e3bzPjxYP/39e421381b97dc89bb189cb35496095c/02-enable-custom-database)

On this screen, you can enable the **Use my own database** option and define the JavaScript that will run when the following events are triggered:

* **Login** - executed each time a user attempts to login, to validate the authenticity of the user against a MongoDB record;
* **Create** - executed when the user signs up, to create a record in MongoDB;
* **Verify** - executed after a user signs up and follows the email "verification" link, to set a corresponding flag in MongoDB;
* **Change Password** - executed when the user changes their password, or the reset email was sent and the user follows the "change password" link, to update a record in MongoDB;
* **Get User** - executed to determine the current state of existence of a user, which returns a matching MongoDB record if any, without requiring the user's credentials; and
* **Delete** - executed when a user is deleted, to deactivate or delete the respective MongoDB record.

For each of these scripts, you'll see a **Templates** drop-down above the code editor, and MongoDB is one of the options that come out of the box. You'll come back to this later.

![Using a predefined custom database script template](https://images.ctfassets.net/23aumh6u8s0i/1tHHzz76Yla76NbwM0Y7H0/b90b814d25bb6eb9600156ee00c82d32/02-custom-db-script-editor)

## Setting up a MongoDB Cluster

Before you do that, though, set up your MongoDB instance. Assuming you already have an account at [https://mongodb.com/](https://mongodb.com/), head to your dashboard and go to the **Projects** tab. Then create a new project, and in that project, create a new cluster. The free, shared clusters with the default settings are sufficient for our purposes, but you might want to consider one of the paid options if their features better suit your needs.

>This guide should also work fine if you're using an existing database, but you might need to tweak some of the upcoming instructions to your specific circumstances.

Once the cluster is built, which can take up to three minutes, you need some connection details to use in the scripts back in the Auth0 dashboard.

Click on the **Connect** button, and configure the IP Addresses that can connect to your cluster. If you look back in the Auth0 interface, you'll see a list of IP addresses under the code editors for any of your scripts. Add these in using the **Add a different IP Address** button in MongoDB.

![Finding Auth0's IP addresses for allowing access to MongoDB](https://images.ctfassets.net/23aumh6u8s0i/5OM015On791Fbrcfx6VvvV/52cad1ca1e118ceb94547c93ecf8a6cf/auth0-ip-addresses-closeup)

The next thing you need to do is define a user that's allowed to connect to the system. Choose a username and sufficiently strong password, and continue.

Finally, you get to choose a connection method. The scripts you're configuring in Auth0 fall under the **Connect your Application** scenario, and clicking on this will reveal the connection string you need to use in your scripts.

![Obtaining connection details from MongoDB](https://images.ctfassets.net/23aumh6u8s0i/4cSocZbkMPCMFOggiaXyT0/6ec4e02b4cb76cd64d09197d1d4964b7/03-mongodb-connection-details-window)

## Defining the Auth0 Custom Database Scripts

Copy the connection string from MongoDB, and switch back to the Auth0 interface. Select to edit the **Login** script, and choose MongoDB from the templates drop-down.

You'll see the following line in the code:

``` javascript  
const client = new MongoClient('mongodb://user:pass@localhost');
```

Replace the entire connection string with the value you just copied from MongoDB, and you'll see something that looks like:

``` javascript  
const client = new MongoClient('mongodb+srv://user:<password>@xxx.mongodb.net/<dbname>?...');
```

You can remove `<dbname>` from this connection string, because it's already specified later in the script.

``` javascript  
const client = new MongoClient('mongodb+srv://user:<password>@xxx.mongodb.net/?...');
```

Now you need to replace `<password>` with the actual password, but you know it's bad practice to keep these in the scripts.

There's a solution for this, though. Under the script editor, you'll see a **Settings** section that allows you to store data exposed to all the scripts via environment variables. This is a much more secure way to store the password.

Add a key/value pair with the key `MONGO_PASSWORD` and the password you provided when configuring access in MongoDB.

![Storing credentials securely for use in Auth0 custom database scripts](https://images.ctfassets.net/23aumh6u8s0i/2qRxG3H9r2JrR8oAkKuhUn/b2c23edc2154e7482165fc8623eacc53/04-custom-db-script-settings-window)

You'll then be able to copy the **Code Snippet** from the new entry, and use that in your connection string instead:

``` javascript  
const client = new MongoClient('mongodb+srv://user:' + configuration.MONGO_PASSWORD + '@xxx.mongodb.net/<dbname>?...');
```

## Creating the Mongodb Database to Store Users In

The next thing you'll need to do is create a database and collection in MongoDB. Jumping to the MongoDB interface again, close the dialog box containing the connection information and click on the **Collections** button.

On the Collections page, click the **Add My Own Data** button, and provide the database name `db-name` and the collection name `users` and click **Create** to continue.

![Creating a database and collection in MongoDB](https://images.ctfassets.net/23aumh6u8s0i/2FGBFo0xCA7WIuAv1rBeTj/d9fc99f7483d0adc4d969845c2aed954/05-create-db-and-collection-window)

That's it for this step! The database is ready, and you just need to finish up the Auth0 custom database configuration.

## Finalizing the Auth0 Custom Database Scripts

Switch back to the Auth0 interface again and you should see the **Login** script editor. The script is already connecting to the `db-name` database and pulling users out of the `users` collection. If you used other names in the previous step, make sure you update the code in all the scripts on around lines 8 to 10:

![Code showing database and connection name definitions](https://images.ctfassets.net/23aumh6u8s0i/J3utFvV9KFRfeUuy2Vwax/d2cb5e1ef195473184403244a1daf165/script-configure-db-and-connection-names)

Before you move on, copy line 4 into your clipboard, which instantiates the client with the correct connection string.

To configure the other scripts, simply iterate through each one, select MongoDB from the templates dropdown, and replace the client instantiation line with the one you just copied from the **Login** script.

There are just two more little changes you'll need to make to make everything work.

By default, each new user won't have an `email_verified` flag at all, so setting it later won't work. To remedy this, head back to the **Create** script, and find the line that defines the value of `user.password`:

``` javascript  
user.password = hash
```

This is probably line 24. Directly after this line, add the following:

``` javascript  
user.email_verified = false
```

Now, when someone creates a new account, the new user object in MongoDB will be created with the `email_verified` flag as false.

The second change is to the **Delete** script. On around line 11, you'll see the line that tells MongoDB to delete the user:

``` javascript  
users.remove({ _id: id }, function (err) {
```

The issue here is that the value of `id` is the user's email address, whereas the `_id` in MongoDB is an object ID. Change the key in this filter to `email` in order to correctly identify the MongoDB record to be removed:

``` javascript  
users.remove({ email: id }, function (err) {
```

Clicking on the **Save** button above the code editor will save all changes in all the scripts. So hit that, and you're done!

## Testing the Database

You can use the **Try** button to test each of these scripts out now. If you're starting with a new database, try the **Create** script first, and go from there.

![Testing the Auth0 custom database by creating a new user](https://images.ctfassets.net/23aumh6u8s0i/1hc21gDm65ROXTXVQstdYB/8becfaa89d9735532be3d1c449a9a208/06-user-created)

If you're using an existing database, you can try logging in with an existing user's credentials. If you're having authentication issues, make sure the **Login** script is using the same hashing mechanism as the code that generated these users in the first place.

And if you're having trouble, head over to our Community Forum and drop your request below.


Ben Dechrai

Developer Day Helps Developers Build the Future of Identity

Auth0 Actions Is Now Generally Available

Connecting Auth0 to MongoDB

Try for free today