with-context | Decorator for new React Context API | Architecture library

It is simply saying to use the same React context that the custom hook/component is using, not some other "random" auth provider.

Example Auth Context:

Actually only suspendCoroutine can be used to translate a callback-based API into coroutines. withContext doesn't have the effect of suspending a coroutine, but temporarily changing its context (this is mainly about changing the dispatcher). The coroutine immediately continues in the other context and then comes back to the caller's context.

Depending on the project requirements/budget/timeline, the JWT can be created by the developer, or it can be managed by a third party (e.g. Auth0).

• Receives user credentials (e.g. username & password)
• Validates user credentials (e.g. compare username's stored hashed password in the database to the result of hashing the password from the request)
• If token is valid, server responds with a token that is used to authenticate future requests (often automatically stored in a cookie in the client by passing it in the proper header in the auth server's response, which can then be automatically included with every request).
• Can be written from scratch (allowing for more customization), or can be handled by tools such as Auth0

This scenario involves making authenticated requests to a third party API.

• Your frontend accepts user credentials
• Your backend ("authentication server") validates credentials
• Your backend responds with a JWT token, created using the RSA Key from SAP, your User ID from SAP, and likely the User ID from your backend server so that you can ensure that the user making a request to authorized to access the data requested. NOTE: Auth0 can be used to create the token, if it supports storing and passing custom values to the JWT
• Your frontend makes a request to your backend, including the JWT
• Your backend ensures authorization (Auth0 can be used if it supports creating custom logic for checking authorization), then makes the relevant request (based on the request from the frontend) to the SAP server and passes both the JWT and the API Key (stored on your server) with the request
• SAP verifies the JWT, and responds to your backend with the requested data
• Your backend then passes the relevant data to your frontend

This scenario uses a third party auth server to authenticate/authorize routes on both your frontend and backend (both of which will leverage Auth0 tooling).

• Your frontend directs the user to Auth0's login page
• Auth0 redirects back to your frontend, where it stores the JWT
• When a user clicks on a button on your frontend that takes them to a different route (e.g. /profile), your frontend can use Auth0 to see if they are authenticated/authorized and extract relevant user data.
• When a user clicks on a button on your frontend that makes an API request to your backend, it sends the JWT token with the request, which your backend uses for authenticates using Auth0, and then responds with the relevant data (if the user is authorized to receive it).

You have two mistakes:

1. useContext(LoaderContext) returns a tuple (with your implementation), so you need the setter function:

After an intense session of googling , I found the answer here.

I believe you're just misreading your output.

While the above mentioned question seems to hint at the possibility to specify the FriendlyAppName as a string, my tests didn't come to the right results and Microsoft's documentation seems to indicate that it needs to be a lookup into a file resource.

Hence my current "solution" is to write to the HKCR\Local Settings\Software\Microsoft\Windows\Shell\MuiCache key and the associated value for my application as follows:

withContext creates a new job. This means that all coroutines launched inside are children of this job. It only returns when the job is finished. Because of structured concurrency, it only finishes when all child coroutines are finished too.

When any of the child jobs fails, the parent job is canceled. This will also cancel all other child jobs. Since withContext returns a result, the exception is thrown.

The documentation of CoroutineScope is helpful in this regards:

Every coroutine builder (like launch, async, etc) and every scoping function (like coroutineScope, withContext, etc) provides its own scope with its own Job instance into the inner block of code it runs. By convention, they all wait for all the coroutines inside their block to complete before completing themselves, thus enforcing the discipline of structured concurrency.

I think the documentation of withContext could be improved too. The documentation of Job and CoroutineContext are very helpful as they provide a more high-level point of view.

Furthermore, does that mean that we can use coroutineScope and withContext(coroutineContext) interchangeably, the only difference being a bit less boilerplate?

Yes, they should behave the same way. They are intended for different use cases though.

coroutineScope is meant to provide a scope for multiple parallel coroutines in which all will be canceled, if any fails.

withContext is designed to be used to switch the context (eg. the Dispatcher) for the given block of code.

Here is a similar question I recently asked on the kotlin discussion forums. The thread contains some more similar cases and further insight.

You could put a macrolet into your macro expansion: