// based on CreateRequestDelegate() https://github.com/aspnet/AspNetCore/blob/master/src/Middleware/StaticFiles/src/StaticFilesEndpointRouteBuilderExtensions.cs#L194
private static RequestDelegate CreateProxyRequestDelegate(
IEndpointRouteBuilder endpoints,
SpaOptions options,
string npmScript,
int port = 8080,
ScriptRunnerType runner = ScriptRunnerType.Npm,
string regex = VueCliMiddleware.DefaultRegex)
{
if (endpoints == null) { throw new ArgumentNullException(nameof(endpoints)); }
if (options == null) { throw new ArgumentNullException(nameof(options)); }
if (npmScript == null) { throw new ArgumentNullException(nameof(npmScript)); }
var app = endpoints.CreateApplicationBuilder();
app.Use(next => context =>
{
// Set endpoint to null so the SPA middleware will handle the request.
context.SetEndpoint(null);
return next(context);
});
app.UseSpa(opt =>
{
if (options != null)
{
opt.Options.DefaultPage = options.DefaultPage;
opt.Options.DefaultPageStaticFileOptions = options.DefaultPageStaticFileOptions;
opt.Options.SourcePath = options.SourcePath;
opt.Options.StartupTimeout = options.StartupTimeout;
}
opt.UseVueCli(npmScript, port, runner, regex);
});
return app.Build();
}
public DefaultSpaBuilder(IApplicationBuilder application, Assembly assembly, SeedSpaOptions server, SpaOptions options)
{
_application = application;
_server = server;
_options = options;
_assembly = assembly;
}
private static (SpaOptions opts, IOptions <SpaOptions> options) SetupOptions()
{
var opts = new SpaOptions();
var options = Substitute.For <IOptions <SpaOptions> >();
options.Value.Returns(opts);
return(opts, options);
}
public DefaultSpaBuilder(IApplicationBuilder applicationBuilder, SpaOptions options)
{
ApplicationBuilder = applicationBuilder
?? throw new ArgumentNullException(nameof(applicationBuilder));
Options = options
?? throw new ArgumentNullException(nameof(options));
}
/// <summary>
/// Constructs a new instance of <see cref="SpaOptions"/>.
/// </summary>
/// <param name="copyFromOptions">An instance of <see cref="SpaOptions"/> from which values should be copied.</param>
internal SpaOptions(SpaOptions copyFromOptions)
{
_defaultPage = copyFromOptions.DefaultPage;
_packageManagerCommand = copyFromOptions.PackageManagerCommand;
DefaultPageStaticFileOptions = copyFromOptions.DefaultPageStaticFileOptions;
SourcePath = copyFromOptions.SourcePath;
DevServerPort = copyFromOptions.DevServerPort;
}
public AccountService(UserManager <TIdentity> userManager,
UrlEncoder urlEncoder,
SpaOptions spaOptions,
ILogger <AccountService <TIdentity> > logger)
{
_userManager = userManager;
_urlEncoder = urlEncoder;
_spaOptions = spaOptions;
_logger = logger;
}
public static IEndpointConventionBuilder MapToVueCliProxy(
this IEndpointRouteBuilder endpoints,
SpaOptions options,
string npmScript = "serve",
int port = 8080,
ScriptRunnerType runner = ScriptRunnerType.Npm,
string regex = VueCliMiddleware.DefaultRegex)
{
return(endpoints.MapFallback("{*path}", CreateProxyRequestDelegate(endpoints, options, npmScript, port, runner, regex)));
}
public static IEndpointConventionBuilder MapToVueCliProxy(
this IEndpointRouteBuilder endpoints,
string pattern,
SpaOptions options,
string npmScript,
int port = 8080,
ScriptRunnerType runner = ScriptRunnerType.Npm,
string regex = VueCliMiddleware.DefaultRegex)
{
if (pattern == null) { throw new ArgumentNullException(nameof(pattern)); }
return endpoints.MapFallback(pattern, CreateProxyRequestDelegate(endpoints, options, npmScript, port, runner, regex));
}
public DefaultSpaBuilder(IApplicationBuilder applicationBuilder, SpaOptions options)
{
// spa.Options.SourcePath = "ClientApp";
ApplicationBuilder = applicationBuilder
?? throw new ArgumentNullException(nameof(applicationBuilder));
/* if (env.IsDevelopment())
* {
* spa.UseReactDevelopmentServer(npmScript: "start");
* }*/
Options = options ?? throw new ArgumentNullException(nameof(options));
}
public SessionHandleService(IHttpContextAccessor httpContext,
HttpClient httpClient,
SchemeOwnerIdentityProviderOptions idpOptions,
SpaOptions spaOptions,
PartyDetailsOptions partyDetailsOptions)
{
_httpContext = httpContext;
_httpClient = httpClient;
_idpOptions = idpOptions;
_spaOptions = spaOptions;
_partyDetailsOptions = partyDetailsOptions;
}
public IdentityService(UserManager <AspNetUser> userManager,
ITenantUsersRepository usersRepository,
ITenantUserBuilder tenantUserBuilder,
IEmailClient emailClient,
EmailTemplatesData templateData,
ITemplateService templateService,
SpaOptions spaOptions,
ILogger <IIdentityService> logger)
: base(usersRepository, userManager, logger, templateData, templateService, emailClient, spaOptions)
{
_tenantUserBuilder = tenantUserBuilder;
}
private static RequestDelegate CreateProxyRequestDelegate(
IEndpointRouteBuilder endpoints,
SpaOptions options,
string npmScript = "serve",
int port = 8080,
ScriptRunnerType runner = ScriptRunnerType.Npm,
string regex = SpaCliMiddleware.DefaultRegex,
bool forceKill = false,
bool useProxy = true)
{
// based on CreateRequestDelegate() https://github.com/aspnet/AspNetCore/blob/master/src/Middleware/StaticFiles/src/StaticFilesEndpointRouteBuilderExtensions.cs#L194
if (endpoints == null)
{
throw new ArgumentNullException(nameof(endpoints));
}
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (npmScript == null)
{
throw new ArgumentNullException(nameof(npmScript));
}
var app = endpoints.CreateApplicationBuilder();
app.Use(next => context =>
{
// Set endpoint to null so the SPA middleware will handle the request.
context.SetEndpoint(null);
return(next(context));
});
app.UseSpa(opt =>
{
if (options != null)
{
opt.Options.DefaultPage = options.DefaultPage;
opt.Options.DefaultPageStaticFileOptions = options.DefaultPageStaticFileOptions;
opt.Options.SourcePath = options.SourcePath;
opt.Options.StartupTimeout = options.StartupTimeout;
}
if (!string.IsNullOrWhiteSpace(npmScript))
{
opt.UseSpaCli(npmScript, port, runner, regex, forceKill, useProxy);
}
});
return(app.Build());
}
private static void UseSpaWithoutIndexHtml(IApplicationBuilder app, Action <ISpaBuilder> configuration)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
// Use the options configured in DI (or blank if none was configured). We have to clone it
// otherwise if you have multiple UseSpa calls, their configurations would interfere with one another.
var optionsProvider = app.ApplicationServices.GetService <IOptions <SpaOptions> >();
var options = new SpaOptions();
var spaBuilder = new DefaultSpaBuilder(app, options);
configuration.Invoke(spaBuilder);
}
public IdentityServiceBase(ITenantUsersRepository usersRepository,
UserManager <AspNetUser> userManager,
ILogger logger,
EmailTemplatesData templateData,
ITemplateService templateService,
IEmailClient emailClient,
SpaOptions spaOptions)
{
_usersRepository = usersRepository;
_userManager = userManager;
_logger = logger;
_templateData = templateData;
_templateService = templateService;
_emailClient = emailClient;
_spaOptions = spaOptions;
}
public WebRootAssetsResolver(IWebHostEnvironment env, IOptions <SpaOptions> options)
{
var files = env.WebRootFileProvider.GetDirectoryContents("/");
string[] EnumerateFiles(string extension) => files.Where(_ => _.Name.EndsWith(extension)).Select(file => $"/{file.Name}").ToArray();
var assetsList = new List <string>();
assetsList.AddRange(EnumerateFiles(".css"));
if (options.Value.IncludeScripts)
{
assetsList.AddRange(EnumerateFiles(".js"));
}
_assets = assetsList.ToArray();
_options = options.Value;
}
public static IEndpointConventionBuilder MapToSpaCliProxy(
this IEndpointRouteBuilder endpoints,
string pattern,
SpaOptions options,
string npmScript = "serve",
int port = 8080,
ScriptRunnerType runner = ScriptRunnerType.Npm,
string regex = SpaCliMiddleware.DefaultRegex,
bool forceKill = false,
bool useProxy = true)
{
if (pattern == null)
{
throw new ArgumentNullException(nameof(pattern));
}
return(endpoints.MapFallback(pattern, CreateProxyRequestDelegate(endpoints, options, npmScript, port, runner, regex, forceKill, useProxy)));
}
public static void UsePreactDevelopmentServer(
this ISpaBuilder builder, string script)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
SpaOptions options = builder.Options;
if (string.IsNullOrEmpty(options.SourcePath))
{
throw new InvalidOperationException($"To use {nameof(UsePreactDevelopmentServer)}, you must supply a non-empty value for the {nameof(SpaOptions.SourcePath)} property of {nameof(SpaOptions)} when calling {nameof(SpaApplicationBuilderExtensions.UseSpa)}.");
}
if (string.IsNullOrEmpty(script))
{
throw new InvalidOperationException(
$"You must specify a valid npm script name to start the development server");
}
PreactDevelopmentServerMiddleware.Attach(builder, script);
}
public async void RendererDefaultTest()
{
// arrange
var nodeJsService = Substitute.For <INodeJSService>();
var opts = new SpaOptions();
var options = Substitute.For <IOptions <SpaOptions> >();
var telemetryProvider = Substitute.For <ITelemetryProvider>();
var assetsResolver = Substitute.For <IAssetsResolver>();
var requestFeature = Substitute.For <IHttpRequestFeature>();
var context = new DefaultHttpContext();
// configure dependencies
assetsResolver.ResolveAssets(context).Returns(new string[] { "asset" });
telemetryProvider.GetCodeSnippet().Returns("snippet");
options.Value.Returns(opts);
// configure path
requestFeature.RawTarget.Returns("/?params");
context.Features.Set(requestFeature);
context.Request.Scheme = "http";
context.Request.Host = new HostString("localhost:3000");
var renderer = new JeringServerRenderer(nodeJsService, options, telemetryProvider, assetsResolver);
const string expected = "<html></html>";
var json = JsonSerializer.Serialize(new { html = expected });
var doc = JsonDocument.Parse(json);
nodeJsService.InvokeFromFileAsync <JsonElement>(opts.SsrScriptPath, "default", Arg.Any <object[]>())
.Returns(Task.FromResult(doc.RootElement));
// act
var actual = await renderer.RenderHtmlPageAsync(context);
// assert
Assert.Equal(expected, actual);
}
public SpaRuntimeConfig(SpaOptions options)
{
AuthorityUrl = options.AuthorityUrl;
ProductsUrl = options.ProductsUrl;
}
