@freemework/hosting
Version:
Hosting library of the Freemework Project.
199 lines • 10.2 kB
JavaScript
export var FHostingSettings;
(function (FHostingSettings) {
let ClientCertificateMode;
(function (ClientCertificateMode) {
/**
* The server will NOT request a certificate from clients that connect WILL NOT validate the certificate.
*/
ClientCertificateMode["NONE"] = "none";
/**
* The server WILL request a certificate from clients that connect and WILL NOT validate the certificate.
* Validate the certificate by yourself.
*/
ClientCertificateMode["REQUEST"] = "request";
/**
* The server WILL request a certificate from clients that connect and validate the certificate
* Rejects untrusted certificate
*/
ClientCertificateMode["TRUST"] = "trust";
/**
* The server WILL retrieve a certificate from the HTTP header X-Forwarded-Client-Cert and validate the certificate.
* Rejects untrusted certificate
* Hist: Use $ssl_client_escaped_cert NGINX variable to set X-Forwarded-Client-Cert header inside configuration.
*/
ClientCertificateMode["XFCC"] = "xfcc";
})(ClientCertificateMode = FHostingSettings.ClientCertificateMode || (FHostingSettings.ClientCertificateMode = {}));
function fromConfigurationWebServer(configuration, serverName) {
const serverType = configuration.get("type").asString;
const handleUpgrade = configuration.get("handleUpgrade", "true").asBoolean;
switch (serverType) {
case "http": {
let trustProxy = null;
if (configuration.has("trustProxy")) {
trustProxy = FHostingSettings.fromConfigurationTrustProxy(configuration.get("trustProxy").asString);
}
if (configuration.has("clientCertificateMode")) {
const clientCertificateMode = configuration.get("clientCertificateMode").asString;
if (clientCertificateMode !== FHostingSettings.ClientCertificateMode.XFCC) {
throw new Error(`Unsupported value for clientCertificateMode: ${clientCertificateMode}`);
}
const serverOpts = {
type: serverType,
name: serverName,
handleUpgrade,
listenHost: configuration.get("listenHost").asString,
listenPort: configuration.get("listenPort").asIntegerPositive,
...(trustProxy !== null ? { trustProxy } : {}),
clientCertificateMode,
caCertificates: configuration.get("caCertificates").asString // caCertificates requires for validate client certificates
};
return serverOpts;
}
else {
const serverOpts = {
type: serverType,
name: serverName,
handleUpgrade,
listenHost: configuration.get("listenHost").asString,
listenPort: configuration.get("listenPort").asIntegerPositive,
...(trustProxy !== null ? { trustProxy } : {}),
};
return serverOpts;
}
}
case "https": {
let serverOpts;
let trustProxy = null;
if (configuration.has("trustProxy")) {
trustProxy = FHostingSettings.fromConfigurationTrustProxy(configuration.get("trustProxy").asString);
}
let serverKeyPassword = null;
if (configuration.has("serverKeyPassword")) {
serverKeyPassword = configuration.get("serverKeyPassword").asString;
}
const clientCertMode = configuration.get("clientCertificateMode").asString;
switch (clientCertMode) {
case ClientCertificateMode.NONE:
case ClientCertificateMode.REQUEST:
if (configuration.has("caCertificates")) {
serverOpts = {
type: serverType,
name: serverName,
handleUpgrade,
listenHost: configuration.get("listenHost").asString,
listenPort: configuration.get("listenPort").asInteger,
serverCertificate: configuration.get("serverCertificate").asString,
serverKey: configuration.get("serverKey").asString,
...(serverKeyPassword !== null ? { serverKeyPassword } : {}),
...(trustProxy !== null ? { trustProxy } : {}),
clientCertificateMode: clientCertMode,
caCertificates: configuration.get("caCertificates").asString
};
}
else {
serverOpts = {
type: serverType,
name: serverName,
handleUpgrade,
listenHost: configuration.get("listenHost").asString,
listenPort: configuration.get("listenPort").asIntegerPositive,
serverCertificate: configuration.get("serverCertificate").asString,
serverKey: configuration.get("serverKey").asString,
...(serverKeyPassword !== null ? { serverKeyPassword } : {}),
...(trustProxy !== null ? { trustProxy } : {}),
clientCertificateMode: clientCertMode,
};
}
break;
case ClientCertificateMode.TRUST:
case ClientCertificateMode.XFCC:
serverOpts = {
type: serverType,
name: serverName,
handleUpgrade,
listenHost: configuration.get("listenHost").asString,
listenPort: configuration.get("listenPort").asIntegerPositive,
caCertificates: configuration.get("caCertificates").asString,
serverCertificate: configuration.get("serverCertificate").asString,
serverKey: configuration.get("serverKey").asString,
...(serverKeyPassword !== null ? { serverKeyPassword } : {}),
...(trustProxy !== null ? { trustProxy } : {}),
clientCertificateMode: clientCertMode
};
break;
default:
throw new Error(`Unsupported value for clientCertificateMode: ${clientCertMode}`);
}
return serverOpts;
}
default:
throw new Error(`Non supported server type: ${serverType}`);
}
}
FHostingSettings.fromConfigurationWebServer = fromConfigurationWebServer;
/**
* @deprecated Use FHostingSettings.fromConfigurationWebServer instead
*/
FHostingSettings.parseWebServer = fromConfigurationWebServer;
function fromConfigurationWebServers(configuration) {
const serverConfigurations = configuration.getArray("server");
const servers = serverConfigurations.map(serverConfiguration => {
let serverName = "Unnamed";
const { namespaceFull } = serverConfiguration;
if (namespaceFull !== null) {
const configurationNamespaceParts = namespaceFull.split(".");
if (configurationNamespaceParts.length > 0) {
// Use name of configuration index
serverName = configurationNamespaceParts[configurationNamespaceParts.length - 1];
}
}
return FHostingSettings.fromConfigurationWebServer(serverConfiguration, serverName);
});
return servers;
}
FHostingSettings.fromConfigurationWebServers = fromConfigurationWebServers;
/**
* @deprecated Use FHostingSettings.fromConfigurationWebServers instead
*/
FHostingSettings.parseWebServers = fromConfigurationWebServers;
function fromConfigurationTrustProxy(val) {
switch (val) {
case "true": return true;
case "false": return false;
case "loopback":
case "linklocal":
case "uniquelocal":
return val;
default:
throw new Error(`Wrong value for trustProxy: ${val}`);
}
}
FHostingSettings.fromConfigurationTrustProxy = fromConfigurationTrustProxy;
/**
* @deprecated Use FHostingSettings.fromConfigurationTrustProxy instead
*/
FHostingSettings.parseTrustProxy = fromConfigurationTrustProxy;
})(FHostingSettings || (FHostingSettings = {}));
/**
* @deprecated Use FHostingSettings instead
*/
export var FHostingConfiguration;
(function (FHostingConfiguration) {
/**
* @deprecated Use FHostingSettings.ClientCertificateMode instead
*/
FHostingConfiguration.ClientCertificateMode = FHostingSettings.ClientCertificateMode;
/**
* @deprecated Use FHostingSettings.parseWebServer instead
*/
FHostingConfiguration.parseWebServer = FHostingSettings.parseWebServer;
/**
* @deprecated Use FHostingSettings.parseWebServers instead
*/
FHostingConfiguration.parseWebServers = FHostingSettings.parseWebServers;
/**
* @deprecated Use FHostingSettings.parseTrustProxy instead
*/
FHostingConfiguration.parseTrustProxy = FHostingSettings.parseTrustProxy;
})(FHostingConfiguration || (FHostingConfiguration = {}));
//# sourceMappingURL=f_hosting_settings.js.map