spec-3nweb-server 1.6.4 → 1.7.0

package/build/config/letsencrypt.js

@@ -0,0 +1,62 @@
+"use strict";
+/*
+ Copyright (C) 2023 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sslOptsFromConfig = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+function sslOptsFromConfig(letsencrypt, sslOpts, skipReloadOnCertsChange) {
+    if (!sslOpts) {
+        sslOpts = {};
+    }
+    if (letsencrypt) {
+        sslOpts.cert = (0, fs_1.readFileSync)((0, path_1.join)(letsencrypt, 'fullchain.pem'));
+        sslOpts.key = (0, fs_1.readFileSync)((0, path_1.join)(letsencrypt, 'privkey.pem'));
+        if (skipReloadOnCertsChange) {
+            return { sslOpts };
+        }
+        const onCertsUpdate = makeCertsUpdatesWatch();
+        return { sslOpts, onCertsUpdate };
+    }
+    else if (sslOpts.cert && sslOpts.key) {
+        sslOpts.cert = (0, fs_1.readFileSync)(sslOpts.cert);
+        sslOpts.key = (0, fs_1.readFileSync)(sslOpts.key);
+        if (skipReloadOnCertsChange) {
+            return { sslOpts };
+        }
+        const onCertsUpdate = makeCertsUpdatesWatch();
+        return { sslOpts, onCertsUpdate };
+    }
+    else if ((!sslOpts.cert && sslOpts.key)
+        || (sslOpts.cert && !sslOpts.key)) {
+        throw new Error(`servicesConnect.sslOpts section must have both key and cert fields pointing to respective files.`);
+    }
+    else {
+        return;
+    }
+}
+exports.sslOptsFromConfig = sslOptsFromConfig;
+function makeCertsUpdatesWatch(
+// XXX pass locations, or some fs watching object
+) {
+    return listener => {
+        // XXX start watching a signal
+        const stopWatching = () => { };
+        return stopWatching;
+    };
+}
+Object.freeze(exports);

package/build/config/signup.d.ts

@@ -0,0 +1,15 @@
+import { MultiDomainSignupCtx, SingleUserSignupCtx } from "../admin/signup-tokens";
+export declare function addSingleUserSignup(rootFolder: string, userId: string): Promise<string>;
+export declare function addMultiDomainSignup(rootFolder: string, domains: string[]): Promise<string>;
+export declare function readNoTokensFile(noTokenFile: string): Promise<MultiDomainSignupCtx>;
+export declare function readTokenFile(rootFolder: string, tokenId: string): Promise<SingleUserSignupCtx | MultiDomainSignupCtx | undefined>;
+export declare function readAllSignupTokens(rootFolder: string): Promise<{
+    singleUserTokens: {
+        tokenId: string;
+        ctx: SingleUserSignupCtx;
+    }[];
+    multiUserTokens: {
+        tokenId: string;
+        ctx: MultiDomainSignupCtx;
+    }[];
+}>;

package/build/config/signup.js

@@ -0,0 +1,132 @@
+"use strict";
+/*
+ Copyright (C) 2019 - 2020 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readAllSignupTokens = exports.readTokenFile = exports.readNoTokensFile = exports.addMultiDomainSignup = exports.addSingleUserSignup = void 0;
+const async_fs_node_1 = require("../lib-common/async-fs-node");
+const signup_tokens_1 = require("../admin/signup-tokens");
+const server_data_folders_1 = require("../lib-server/resources/server-data-folders");
+const error_1 = require("../lib-common/exceptions/error");
+const path_1 = require("path");
+async function addSingleUserSignup(rootFolder, userId) {
+    const token = await (0, signup_tokens_1.generateToken)();
+    const ctx = (0, signup_tokens_1.makeSingleUserSignupCtx)(token, userId);
+    const fPath = (0, signup_tokens_1.tokenPath)(rootFolder, token);
+    try {
+        await (0, async_fs_node_1.writeFile)(fPath, JSON.stringify(ctx), { encoding: 'utf8', flag: 'wx' });
+        return token;
+    }
+    catch (exc) {
+        if (exc.alreadyExists) {
+            return addSingleUserSignup(rootFolder, userId);
+        }
+        else if (exc.notFound) {
+            await (0, async_fs_node_1.mkdir)((0, server_data_folders_1.tokensInRootFolder)(rootFolder))
+                .catch((exc) => {
+                if (!exc.alreadyExists) {
+                    throw exc;
+                }
+            });
+            return addSingleUserSignup(rootFolder, userId);
+        }
+        else {
+            throw exc;
+        }
+    }
+}
+exports.addSingleUserSignup = addSingleUserSignup;
+async function addMultiDomainSignup(rootFolder, domains) {
+    const token = await (0, signup_tokens_1.generateToken)();
+    const ctx = (0, signup_tokens_1.makeMultiDomainSignupCtx)(domains, token);
+    const fPath = (0, signup_tokens_1.tokenPath)(rootFolder, token);
+    try {
+        await (0, async_fs_node_1.writeFile)(fPath, JSON.stringify(ctx), { encoding: 'utf8', flag: 'wx' });
+        return token;
+    }
+    catch (exc) {
+        if (exc.alreadyExists) {
+            return addMultiDomainSignup(rootFolder, domains);
+        }
+        else if (exc.notFound) {
+            await (0, async_fs_node_1.mkdir)((0, server_data_folders_1.tokensInRootFolder)(rootFolder))
+                .catch((exc) => {
+                if (!exc.alreadyExists) {
+                    throw exc;
+                }
+            });
+            return addMultiDomainSignup(rootFolder, domains);
+        }
+        else {
+            throw exc;
+        }
+    }
+}
+exports.addMultiDomainSignup = addMultiDomainSignup;
+async function readNoTokensFile(noTokenFile) {
+    try {
+        const str = await (0, async_fs_node_1.readFile)(noTokenFile, { encoding: 'utf8' });
+        return JSON.parse(str);
+    }
+    catch (err) {
+        throw (0, error_1.errWithCause)(err, `Fail to read "no tokens" signup context file ${noTokenFile}`);
+    }
+}
+exports.readNoTokensFile = readNoTokensFile;
+async function readTokenFile(rootFolder, tokenId) {
+    try {
+        const fPath = (0, path_1.join)((0, server_data_folders_1.tokensInRootFolder)(rootFolder), tokenId);
+        const str = await (0, async_fs_node_1.readFile)(fPath, { encoding: 'utf8' });
+        const ctx = JSON.parse(str);
+        if (!ctx.token) {
+            return;
+        }
+        else if (ctx.type === 'multi-domain') {
+            return (ctx.domains ? ctx : undefined);
+        }
+        else if (ctx.type === 'single-user') {
+            return (ctx.userId ? ctx : undefined);
+        }
+        else {
+            return;
+        }
+    }
+    catch (err) {
+        console.error(err);
+        return;
+    }
+}
+exports.readTokenFile = readTokenFile;
+async function readAllSignupTokens(rootFolder) {
+    const singleUserTokens = [];
+    const multiUserTokens = [];
+    const tokenIds = await (0, async_fs_node_1.readdir)((0, server_data_folders_1.tokensInRootFolder)(rootFolder));
+    for (const tokenId of tokenIds) {
+        const ctx = await readTokenFile(rootFolder, tokenId);
+        if (!ctx) {
+            continue;
+        }
+        if (ctx.type === 'multi-domain') {
+            multiUserTokens.push({ tokenId, ctx });
+        }
+        else {
+            singleUserTokens.push({ tokenId, ctx });
+        }
+    }
+    return { multiUserTokens, singleUserTokens };
+}
+exports.readAllSignupTokens = readAllSignupTokens;
+Object.freeze(exports);

package/build/lib-server/resources/dns.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2015 - 2016 3NSoft Inc.
+ Copyright (C) 2015 - 2016, 2023 3NSoft Inc.
  
  This program is free software: you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
@@ -39,19 +39,57 @@ Object.freeze(DNS_ERR_CODE);
  */
 function extractPair(txtRecords, serviceLabel) {
     for (const txtRecord of txtRecords) {
-        const txt = txtRecord.join(' ');
-        const eqPos = txt.indexOf('=');
-        if (eqPos < 0) {
-            continue;
-        }
-        const name = txt.substring(0, eqPos).trim();
-        if (name === serviceLabel) {
-            const value = txt.substring(eqPos + 1).trim();
-            return value;
+        let joinedTXTstanzas = txtRecord.join('');
+        let record = getRecordAtStartOf(joinedTXTstanzas);
+        while (record) {
+            if (record.service === serviceLabel) {
+                const value = record.value.trim();
+                if (value.length > 0) {
+                    return value;
+                }
+            }
+            if (record.txtTail) {
+                record = getRecordAtStartOf(record.txtTail);
+            }
+            else {
+                break;
+            }
         }
     }
     return;
 }
+const recordsStarts = {
+    "3nstorage": '3nstorage=',
+    asmail: 'asmail=',
+    mailerid: 'mailerid='
+};
+function getRecordAtStartOf(txt) {
+    let service = undefined;
+    for (const [label, startSeq] of Object.entries(recordsStarts)) {
+        if (txt.startsWith(startSeq)) {
+            service = label;
+            txt = txt.substring(startSeq.length);
+            break;
+        }
+    }
+    if (!service) {
+        return;
+    }
+    for (const delimiter of Object.values(recordsStarts)) {
+        const endPos = txt.indexOf(delimiter);
+        if (endPos >= 0) {
+            return {
+                service,
+                value: txt.substring(0, endPos),
+                txtTail: txt.substring(endPos)
+            };
+        }
+    }
+    return {
+        service,
+        value: txt
+    };
+}
 function resolveTxt(domain) {
     return new Promise((resolve, reject) => {
         // As of March 2017, docs for node say that texts given in a callback

package/build/lib.d.ts

@@ -1,5 +1,6 @@
 export { AppWithWSs } from './lib-server/web-sockets/app';
 export { Configurations, servicesApp, adminApp } from './services';
-export { addSingleUserSignup, getConfsFromEnv, getBindParamsFromEnv } from './run-config';
+export { getConfsFromEnv, getBindParamsFromEnv } from './config/from-env';
+export { addSingleUserSignup } from './config/signup';
 export import errors = require('./lib-server/middleware/error-handler');
 export * as mock from './mock/run-in-proc';

package/build/lib.js

@@ -16,16 +16,17 @@
  this program. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mock = exports.getBindParamsFromEnv = exports.getConfsFromEnv = exports.addSingleUserSignup = exports.adminApp = exports.servicesApp = exports.AppWithWSs = void 0;
+exports.mock = exports.addSingleUserSignup = exports.getBindParamsFromEnv = exports.getConfsFromEnv = exports.adminApp = exports.servicesApp = exports.AppWithWSs = void 0;
 var app_1 = require("./lib-server/web-sockets/app");
 Object.defineProperty(exports, "AppWithWSs", { enumerable: true, get: function () { return app_1.AppWithWSs; } });
 var services_1 = require("./services");
 Object.defineProperty(exports, "servicesApp", { enumerable: true, get: function () { return services_1.servicesApp; } });
 Object.defineProperty(exports, "adminApp", { enumerable: true, get: function () { return services_1.adminApp; } });
-var run_config_1 = require("./run-config");
-Object.defineProperty(exports, "addSingleUserSignup", { enumerable: true, get: function () { return run_config_1.addSingleUserSignup; } });
-Object.defineProperty(exports, "getConfsFromEnv", { enumerable: true, get: function () { return run_config_1.getConfsFromEnv; } });
-Object.defineProperty(exports, "getBindParamsFromEnv", { enumerable: true, get: function () { return run_config_1.getBindParamsFromEnv; } });
+var from_env_1 = require("./config/from-env");
+Object.defineProperty(exports, "getConfsFromEnv", { enumerable: true, get: function () { return from_env_1.getConfsFromEnv; } });
+Object.defineProperty(exports, "getBindParamsFromEnv", { enumerable: true, get: function () { return from_env_1.getBindParamsFromEnv; } });
+var signup_1 = require("./config/signup");
+Object.defineProperty(exports, "addSingleUserSignup", { enumerable: true, get: function () { return signup_1.addSingleUserSignup; } });
 exports.errors = require("./lib-server/middleware/error-handler");
 exports.mock = require("./mock/run-in-proc");
 Object.freeze(exports);

package/build/main.js

@@ -16,67 +16,218 @@
  this program. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-/*
- * This script starts server, according to settings, given in config file.
- */
+const cli_1 = require("./config/cli");
+const from_yaml_1 = require("./config/from-yaml");
+const letsencrypt_1 = require("./config/letsencrypt");
 const lib_1 = require("./lib");
-const fs_1 = require("fs");
-const async_fs_node_1 = require("./lib-common/async-fs-node");
-const child_process_1 = require("child_process");
-const processes_1 = require("./lib-common/processes");
-const PID_FILE = '/var/3nweb/service.pid';
-const confFile = process.argv[2];
-if (!confFile) {
-    console.error(`Configuration file is not given. It should be the first script argument.`);
-    process.exit(-1);
-}
-const conf = JSON.parse((0, fs_1.readFileSync)(confFile, 'utf8'));
-const noop = () => { };
-(async () => {
+const signup_1 = require("./config/signup");
+async function run(conf) {
     if (!conf.servicesConnect) {
-        console.error(`No connection settings found in ${confFile}.`);
+        console.error(`No connection settings found in ??.`);
         process.exit(-1);
         return;
     }
-    try {
-        const prevPidStr = await (0, async_fs_node_1.readFile)(PID_FILE, { encoding: 'utf8' });
-        const prevPid = Number.parseInt(prevPidStr);
-        if (!Number.isNaN(prevPid)) {
-            (0, child_process_1.execSync)(`kill -SIGTERM ${prevPid}`);
-            while (!!(0, child_process_1.execSync)(`ps ${prevPid} | grep ${prevPid}`)) {
-                await (0, processes_1.sleep)(1000);
-            }
-            await (0, async_fs_node_1.unlink)(PID_FILE).catch(noop);
-        }
-    }
-    catch (err) {
-        if (!err.notFound) {
-            throw err;
-        }
-    }
     let app = undefined;
+    function createApp(conf) {
+        const app = new lib_1.AppWithWSs();
+        app.use((0, lib_1.servicesApp)(conf, 'console', 'console'));
+        app.use((0, lib_1.adminApp)(conf, 'console', 'console'));
+        return app;
+    }
     async function stopProcess() {
         if (!app) {
             return;
         }
-        app.stop().then(err => console.log(err));
-        app = undefined;
-        (0, async_fs_node_1.unlink)(PID_FILE).catch(noop);
+        try {
+            console.log(`Stopping app ...`);
+            await app.stop();
+            console.log(`app has stopped.`);
+        }
+        catch (err) {
+            console.log(`app encounter an error, when stopping`);
+            console.error(err);
+        }
+        finally {
+            app = undefined;
+        }
     }
-    try {
-        app = new lib_1.AppWithWSs();
-        app.use((0, lib_1.servicesApp)(conf));
-        app.use((0, lib_1.adminApp)(conf));
-        const { hostname, port, sslOpts } = conf.servicesConnect;
+    async function startAppWithTLS(sslOpts, port, hostname) {
         await app.start(sslOpts, port, hostname);
-        console.log(`Started 3NWeb server at address "${hostname}", port ${port}, ${sslOpts ? 'via TLS' : 'without TLS, and requiring TLS reverse proxy infront.'}`);
-        (0, fs_1.writeFileSync)(PID_FILE, `${process.pid}`);
+        console.log(`Started 3NWeb server on port ${port},${hostname ? ` hostname ${hostname},` : ''} with TLS.`);
+    }
+    async function startAppWithoutTLS(port, hostname) {
+        await app.start(undefined, port, hostname);
+        console.log(`Started 3NWeb server on port ${port},${hostname ? ` hostname ${hostname},` : ''} without TLS, and requiring TLS reverse proxy infront.`);
+    }
+    try {
+        app = createApp(conf);
+        const { hostname, port, letsencrypt, sslOpts, skipReloadOnCertsChange } = conf.servicesConnect;
+        const tls = (0, letsencrypt_1.sslOptsFromConfig)(letsencrypt, sslOpts, skipReloadOnCertsChange);
+        if (tls) {
+            await startAppWithTLS(tls.sslOpts, port, hostname);
+            if (!skipReloadOnCertsChange) {
+                tls.onCertsUpdate(async (newOpts, originalOpts) => {
+                    console.log(`Reloading server app server on TLS certificates change`);
+                    try {
+                        await stopProcess();
+                        app = createApp(conf);
+                        await startAppWithTLS(newOpts, port, hostname);
+                    }
+                    catch (err) {
+                        console.error(err);
+                        console.log(`Failed to reload with new TLS certs. Attempting to load with original ones.`);
+                        try {
+                            await stopProcess();
+                            app = createApp(conf);
+                            await startAppWithTLS(originalOpts, port, hostname);
+                        }
+                        catch (err) {
+                            await stopProcess();
+                            console.error(err);
+                            process.exit(-500);
+                        }
+                    }
+                });
+            }
+        }
+        else {
+            await startAppWithoutTLS(port, hostname);
+        }
         process.on('SIGINT', stopProcess);
         process.on('SIGTERM', stopProcess);
     }
     catch (err) {
-        stopProcess();
+        await stopProcess();
         console.error(err);
         process.exit(-500);
     }
-})();
+}
+function showUsage({ txtToDisplay, exitStatus }) {
+    if (exitStatus === 0) {
+        console.log(txtToDisplay);
+    }
+    else {
+        console.error(txtToDisplay);
+    }
+    process.exit(exitStatus);
+}
+function assembleConfig(configPath) {
+    if (configPath) {
+        return (0, from_yaml_1.readYamlConfFile)(configPath);
+    }
+    else {
+        throw new Error(`Config path must be given`);
+    }
+}
+async function displaySignupInfo(conf) {
+    if (!conf.signup) {
+        console.log(`\nSignup is disabled.\n`);
+    }
+    else {
+        console.log(`\nSignup is enabled.\n`);
+        if (conf.signup.noTokenFile) {
+            const ctx = await (0, signup_1.readNoTokensFile)(conf.signup.noTokenFile);
+            console.log(`Signup of user without token is allowed in domains:\n`, ctx.domains, `\n`);
+        }
+        else {
+            console.log(`Signup of users is allowed only with valid signup tokens.\n`);
+        }
+    }
+    const { multiUserTokens, singleUserTokens } = await (0, signup_1.readAllSignupTokens)(conf.rootFolder);
+    console.log(`There are ${multiUserTokens.length} multi-user tokens.\n`);
+    console.log(`There are ${singleUserTokens.length} single-user tokens.\n`);
+}
+async function displayTokensList(conf) {
+    const { multiUserTokens, singleUserTokens } = await (0, signup_1.readAllSignupTokens)(conf.rootFolder);
+    if (multiUserTokens.length > 0) {
+        console.log(`\nMulti-user signup tokens:`);
+        for (const { tokenId, ctx: { domains } } of multiUserTokens) {
+            console.log(`  id: ${tokenId}  -> domains:`, domains);
+        }
+        console.log(``);
+    }
+    else {
+        console.log(`\nThere are no multi-user signup tokens.\n`);
+    }
+    if (singleUserTokens.length > 0) {
+        console.log(`Single-user signup tokens:`);
+        for (const { tokenId, ctx: { userId } } of singleUserTokens) {
+            console.log(`  id: ${tokenId}  -> user: ${userId}`);
+        }
+        console.log(``);
+    }
+    else {
+        console.log(`There are no single-user signup tokens.\n`);
+    }
+}
+async function displayTokenValue(conf, tokenId) {
+    const ctx = await (0, signup_1.readTokenFile)(conf.rootFolder, tokenId);
+    if (!ctx) {
+        console.error(`Token ${tokenId} is not found.`);
+        process.exit(-1);
+    }
+    else if (ctx.type === 'multi-domain') {
+        console.log(`\nMulti-user signup context:`);
+        console.log(`  domains:`, ctx.domains);
+        console.log(`  value:`, ctx.token);
+        if (ctx.validTill) {
+            console.log(`  valid till: ${(new Date(ctx.validTill)).toString()}\n`);
+        }
+        else {
+            console.log(``);
+        }
+    }
+    else if (ctx.type === 'single-user') {
+        console.log(`\nSingle-user signup context:`);
+        console.log(`  address:`, ctx.userId);
+        console.log(`  value:`, ctx.token);
+        if (ctx.validTill) {
+            console.log(`  valid till: ${(new Date(ctx.validTill)).toString()}\n`);
+        }
+        else {
+            console.log(``);
+        }
+    }
+}
+async function createMultiUserToken(conf, domains) {
+    const token = await (0, signup_1.addMultiDomainSignup)(conf.rootFolder, domains);
+    console.log(`\nToken value:\n  ${token}\n`);
+}
+async function createSingleUserToken(conf, userId) {
+    const token = await (0, signup_1.addSingleUserSignup)(conf.rootFolder, userId);
+    console.log(`\nToken value:\n  ${token}\n`);
+}
+const cmd = (0, cli_1.parseProcessArgv)();
+if (cmd.runCmd) {
+    const conf = assembleConfig(cmd.runCmd.config);
+    run(conf);
+}
+else if (cmd.signupCmd) {
+    const conf = assembleConfig(cmd.signupCmd.config);
+    if (cmd.signupCmd.info) {
+        displaySignupInfo(conf);
+    }
+    else if (cmd.signupCmd.listTokens) {
+        displayTokensList(conf);
+    }
+    else if (cmd.signupCmd.showToken) {
+        displayTokenValue(conf, cmd.signupCmd.token);
+    }
+    else if (cmd.signupCmd.createToken) {
+        if (cmd.signupCmd.user) {
+            createSingleUserToken(conf, cmd.signupCmd.user);
+        }
+        else {
+            createMultiUserToken(conf, cmd.signupCmd.domain);
+        }
+    }
+    else {
+        throw new Error(`CLI parser failed to capture invalid command`);
+    }
+}
+else if (cmd.showUsage) {
+    showUsage(cmd.showUsage);
+}
+else {
+    throw new Error(`CLI parser failed to trigger useful action`);
+}

package/build/mock/run-in-proc.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2020 3NSoft Inc.
+ Copyright (C) 2020, 2023 3NSoft Inc.
  
  This program is free software: you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
@@ -37,8 +37,11 @@ function setTestCertsAndDNS(domains, thisSrvLoc) {
     for (const domain of domains) {
         dnsRecs[domain] = [
             ['asmail', '=', `${thisSrvLoc}/asmail`],
-            ['mailerid=', `${thisSrvLoc}/mailerid`],
-            [`3nstorage=${thisSrvLoc}/3nstorage`] // DNS txt without spaces
+            [
+                'mailerid=', `${thisSrvLoc}/mailerid`,
+                `3nstorage=${thisSrvLoc}/3nstorage`
+            ] // two 3NWeb records in one DNS TXT record
+            // XXX add other life-like records
         ];
     }
     const dnsMock = new dns_1.DNSMock(dnsRecs);

package/build/services.d.ts

@@ -12,6 +12,8 @@ export interface Configurations {
         hostname?: string;
         port: number;
         sslOpts?: https.ServerOptions;
+        letsencrypt?: string;
+        skipReloadOnCertsChange?: boolean;
     };
     rootFolder: string;
     domain: string;
@@ -22,5 +24,5 @@ export interface Configurations {
         noTokenFile?: string;
     };
 }
-export declare function servicesApp(conf: Configurations, errLogger?: ErrLogger | 'console'): AppWithWSs;
-export declare function adminApp(conf: Configurations, errLogger?: ErrLogger | 'console'): AppWithWSs;
+export declare function servicesApp(conf: Configurations, errLogger?: ErrLogger | 'console', logSetup?: 'console'): AppWithWSs;
+export declare function adminApp(conf: Configurations, errLogger?: ErrLogger | 'console', logSetup?: 'console'): AppWithWSs;

package/build/services.js

@@ -24,29 +24,38 @@ const asmail_app_1 = require("./asmail/asmail-app");
 const _3nstorage_app_1 = require("./3nstorage/3nstorage-app");
 const admin_app_1 = require("./admin/admin-app");
 const error_handler_1 = require("./lib-server/middleware/error-handler");
-function servicesApp(conf, errLogger) {
+function servicesApp(conf, errLogger, logSetup) {
     if (!conf.enabledServices || (typeof conf.enabledServices !== 'object')) {
         throw new Error('Missing enabled-services sections in confs.');
     }
     const app = new app_1.AppWithWSs();
     const midAuthorizer = (0, mailerid_authorizer_1.validator)(); // share, allowing for caching of certs
     if (conf.enabledServices.mailerId) {
-        app.http.use('/mailerid', (0, mailerId_app_1.makeApp)(conf.rootFolder, conf.domain, conf.mailerId.certs, (errLogger === 'console') ? (0, error_handler_1.makeErrLoggerToConsole)('mailerid') : errLogger));
+        app.http.use('/mailerid', (0, mailerId_app_1.makeApp)(conf.rootFolder, conf.domain, conf.mailerId.certs, (errLogger === 'console') ? (0, error_handler_1.makeErrLoggerToConsole)('MailerId') : errLogger));
+        if (logSetup === 'console') {
+            console.log(`Enabled MailerId service with provider domain ${conf.domain}`);
+        }
     }
     if (conf.enabledServices.asmail) {
-        app.use('/asmail', (0, asmail_app_1.makeApp)(conf.rootFolder, conf.domain, midAuthorizer, (errLogger === 'console') ? (0, error_handler_1.makeErrLoggerToConsole)('asmail') : errLogger));
+        app.use('/asmail', (0, asmail_app_1.makeApp)(conf.rootFolder, conf.domain, midAuthorizer, (errLogger === 'console') ? (0, error_handler_1.makeErrLoggerToConsole)('ASMail') : errLogger));
+        if (logSetup === 'console') {
+            console.log(`Enabled ASMail service with provider domain ${conf.domain}`);
+        }
     }
     if (conf.enabledServices.storage) {
-        app.use('/3nstorage', (0, _3nstorage_app_1.makeApp)(conf.rootFolder, conf.domain, midAuthorizer, (errLogger === 'console') ? (0, error_handler_1.makeErrLoggerToConsole)('storage') : errLogger));
+        app.use('/3nstorage', (0, _3nstorage_app_1.makeApp)(conf.rootFolder, conf.domain, midAuthorizer, (errLogger === 'console') ? (0, error_handler_1.makeErrLoggerToConsole)('3NStorage') : errLogger));
+        if (logSetup === 'console') {
+            console.log(`Enabled 3NStorage service with provider domain ${conf.domain}`);
+        }
     }
     return app;
 }
 exports.servicesApp = servicesApp;
-function adminApp(conf, errLogger) {
+function adminApp(conf, errLogger, logSetup) {
     if (errLogger === 'console') {
         errLogger = (0, error_handler_1.makeErrLoggerToConsole)('3NWeb server admin');
     }
-    return new app_1.AppWithWSs((0, admin_app_1.makeApp)(conf, errLogger));
+    return new app_1.AppWithWSs((0, admin_app_1.makeApp)(conf, errLogger, logSetup));
 }
 exports.adminApp = adminApp;
 Object.freeze(exports);