| Date | Temp. (C) | Temp. (F) | Summary |
|---|---|---|---|
| {{ forecast.date }} | {{ forecast.temperatureC }} | {{ forecast.temperatureF }} | {{ forecast.summary }} |
Razor SSG
| Date | Temp. (C) | Temp. (F) | Summary |
|---|---|---|---|
| {forecast.date} | {forecast.temperatureC} | {forecast.temperatureF} | {forecast.summary} |
Vite Vue SPA Template
Explore the high productivity features in the new ServiceStack Vue SPA template
> The initial load time for the `Interactive WASM` mode can be quite slow even for a minimal app
Our templates previously worked around this limitation with a custom Pre-Rendering solution, as the wait times were too long for a good user experience.
With .NET 8, the new `Interactive Auto` mode provides the best of both worlds as pre-rendering is now enabled by default.
When the page is first loaded, it uses the `Interactive Server` mode, which is faster than `Interactive WASM` as it doesn't need to download WASM resources.
So the user can start interacting with the page straight away, but with a slight delay for each of their interactions due to having to perform round-trips to the server for each interaction.
In the background, the WASM resources are downloaded which can then be used to render the site on the client for subsequent visits.
## Using InteractiveAuto in your Blazor application
In Blazor for .NET 8, render modes can be set on both a per-page and per-component basis.
```html
@page "/counter"
@rendermode InteractiveAuto
### Authenticating with JWT
JWT Identity Auth is a drop-in replacement for ServiceStack's JWT AuthProvider where Authenticating via Credentials
will convert the Authenticated User into a JWT Bearer Token returned in the **HttpOnly**, **Secure** `ss-tok` Cookie
that will be used to Authenticate the client:
```csharp
var client = new JsonApiClient(BaseUrl);
await client.SendAsync(new Authenticate {
provider = "credentials",
UserName = Username,
Password = Password,
});
var bearerToken = client.GetTokenCookie(); // ss-tok Cookie
```
## JWT Refresh Tokens
Refresh Tokens can be used to allow users to request a new JWT Access Token when the current one expires.
To enable support for JWT Refresh Tokens your `IdentityUser` model should implement the `IRequireRefreshToken` interface
which will be used to store the 64 byte Base64 URL-safe `RefreshToken` and its `RefreshTokenExpiry` in its persisted properties:
```csharp
public class ApplicationUser : IdentityUser, IRequireRefreshToken
{
public string? RefreshToken { get; set; }
public DateTime? RefreshTokenExpiry { get; set; }
}
```
Now after successful authentication, the `RefreshToken` will also be returned in the `ss-reftok` Cookie:
```csharp
var refreshToken = client.GetRefreshTokenCookie(); // ss-reftok Cookie
```
### Transparent Server Auto Refresh of JWT Tokens
To be able to terminate a users access, Users need to revalidate their eligibility to verify they're still allowed access
(e.g. deny Locked out users). This JWT revalidation pattern is implemented using Refresh Tokens which are used to request
revalidation of their access and reissuing a new JWT Access Token which can be used to make authenticated requests until it expires.
As Cookies are used to return Bearer and Refresh Tokens ServiceStack is able to implement the revalidation logic on the
server where it transparently validates Refresh Tokens, and if a User is eligible will reissue a new JWT Token Cookie that
replaces the expired Access Token Cookie.
Thanks to this behavior HTTP Clients will be able to Authenticate with just the Refresh Token, which will transparently
reissue a new JWT Access Token Cookie and then continue to perform the Authenticated Request:
```csharp
var client = new JsonApiClient(BaseUrl);
client.SetRefreshTokenCookie(RefreshToken);
var response = await client.SendAsync(new Secured { ... });
```
There's also opt-in sliding support for extending a User's RefreshToken after usage which allows Users to treat
their Refresh Token like an API Key where it will continue extending whilst they're continuously using it to make API requests,
otherwise expires if they stop. How long to extend the expiry of Refresh Tokens after usage can be configured with:
```csharp
options.JwtAuth(x => {
// How long to extend the expiry of Refresh Tokens after usage (default None)
x.ExtendRefreshTokenExpiryAfterUsage = TimeSpan.FromDays(90);
});
```
## Convert Session to Token Service
Another useful Service that's available is being able to Convert your current Authenticated Session into a Token
with the `ConvertSessionToToken` Service which can be enabled with:
```csharp
options.JwtAuth(x => {
x.IncludeConvertSessionToTokenService = true;
});
```
This can be useful for when you want to Authenticate via an external OAuth Provider that you then want to convert into a stateless
JWT Token by calling the `ConvertSessionToToken` on the client, e.g:
#### .NET Clients
```csharp
await client.SendAsync(new ConvertSessionToToken());
```
#### TypeScript/JavaScript
```ts
fetch('/session-to-token', { method:'POST', credentials:'include' })
```
The default behavior of `ConvertSessionToToken` is to remove the Current Session from the Auth Server which will prevent
access to protected Services using our previously Authenticated Session. If you still want to preserve your existing Session
you can indicate this with:
```csharp
await client.SendAsync(new ConvertSessionToToken {
PreserveSession = true
});
```
### JWT Options
Other configuration options available for Identity JWT Auth include:
```csharp
options.JwtAuth(x => {
// How long should JWT Tokens be valid for. (default 14 days)
x.ExpireTokensIn = TimeSpan.FromDays(14);
// How long should JWT Refresh Tokens be valid for. (default 90 days)
x.ExpireRefreshTokensIn = TimeSpan.FromDays(90);
x.OnTokenCreated = (req, user, claims) => {
// Customize which claims are included in the JWT Token
};
// Whether to invalidate Refresh Tokens on Logout (default true)
x.InvalidateRefreshTokenOnLogout = true;
// How long to extend the expiry of Refresh Tokens after usage (default None)
x.ExtendRefreshTokenExpiryAfterUsage = null;
});
```
# Built-In Identity Auth Admin UI
Source: https://servicestack.net/posts/identity-auth-admin-ui
With ServiceStack now [deeply integrated into ASP.NET Core Apps](/posts/servicestack-endpoint-routing) we're back to
refocusing on adding value-added features that can benefit all .NET Core Apps.
## Registration
The new Identity Auth Admin UI is an example of this, which can be enabled when registering the `AuthFeature` Plugin:
```csharp
public class ConfigureAuth : IHostingStartup
{
public void Configure(IWebHostBuilder builder) => builder
.ConfigureServices(services => {
services.AddPlugin(new AuthFeature(IdentityAuth.For
