@silexlabs/silex 3.0.0-alpha.100

package/dist/server/server/cli.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = __importDefault(require("./index"));
+const cli_1 = require("cli");
+const options = (0, cli_1.parse)({
+    'url': ['', 'URL of your server', 'string'],
+    'host': ['', 'Sets the host param of the express module "cookie-session".', 'string'],
+    'port': ['p', 'Port to listen to', 'int'],
+    'protocol': ['', 'Sets the protocol param of the express module "cookie-session".', 'string'],
+    'config': ['c', 'Path for the server side config file to load at startup', 'file'],
+    'client-config': ['', 'Path to client config file to be served on .silex-client.js', 'string'],
+    'fs-root': ['', 'Path to the root folder where to store websites. Used by the default connector (fs).', 'string'],
+    'session-name': ['', 'Sets the name param of the express module "cookie-session".', 'string'],
+    'session-secret': ['s', 'Session secret', 'string'],
+    'ssl-port': [false, 'Port to listen to for SSL/HTTPS', 'int'],
+    'force-https': [false, 'Force HTTPS', 'boolean'],
+    'ssl-private-key': [false, 'Path to private key for SSL', 'file'],
+    'ssl-certificate': [false, 'Path to SSL certificate', 'file'],
+    'force-https-trust-xfp-header': [false, 'Sets the trustXFPHeader param of the express module "cookie-session". Use only with --force-https', 'boolean'],
+    'cors-url': ['', 'Enable CORS for URL (can be "*")', 'string'],
+    'express-json-limit': ['', 'Sets the limit param of the express module "json".', 'string'],
+    'express-text-limit': ['', 'Sets the limit param of the express module "text".', 'string'],
+    'express-urlencoded-limit': ['', 'Sets the limit param of the express module "urlencoded".', 'string'],
+    'debug': [false, 'Debug mode, with live reload, source maps etc.', 'boolean'],
+}, {});
+if (options['url'])
+    process.env.SILEX_URL = options['url'];
+if (options['host'])
+    process.env.SILEX_HOST = options['host'];
+if (options.port)
+    process.env.SILEX_PORT = options.port;
+if (options['protocol'])
+    process.env.SILEX_PROTOCOL = options['protocol'];
+if (options.config)
+    process.env.SILEX_CONFIG = options.config;
+if (options['client-config'])
+    process.env.SILEX_CLIENT_CONFIG = options['client-config'];
+if (options['fs-root'])
+    process.env.SILEX_FS_ROOT = options['fs-root'];
+if (options['session-name'])
+    process.env.SILEX_SESSION_NAME = options['session-name'];
+if (options['session-secret'])
+    process.env.SILEX_SESSION_SECRET = options['session-secret'];
+if (options['ssl-port'])
+    process.env.SILEX_SSL_PORT = options['ssl-port'];
+if (options['force-https'])
+    process.env.SILEX_FORCE_HTTPS = options['force-https'];
+if (options['ssl-private-key'])
+    process.env.SILEX_SSL_PRIVATE_KEY = options['ssl-private-key'];
+if (options['ssl-certificate'])
+    process.env.SILEX_SSL_CERTIFICATE = options['ssl-certificate'];
+if (options['force-https-trust-xfp-header'])
+    process.env.SILEX_FORCE_HTTPS_TRUST_XFP_HEADER = options['force-https-trust-xfp-header'];
+if (options['cors-url'])
+    process.env.SILEX_CORS_URL = options['cors-url'];
+if (options['express-json-limit'])
+    process.env.SILEX_EXPRESS_JSON_LIMIT = options['express-json-limit'];
+if (options['express-text-limit'])
+    process.env.SILEX_EXPRESS_TEXT_LIMIT = options['express-text-limit'];
+if (options['express-urlencoded-limit'])
+    process.env.SILEX_EXPRESS_URLENCODED_LIMIT = options['express-urlencoded-limit'];
+if (options.debug)
+    process.env.SILEX_DEBUG = options.debug;
+(0, index_1.default)();

package/dist/server/server/config.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerConfig = void 0;
+const silex_plugins_1 = require("@silexlabs/silex-plugins");
+const path_1 = require("path");
+const constants_1 = require("../constants");
+const promises_1 = require("fs/promises");
+const connectors_1 = require("./connectors/connectors");
+const FsStorage_1 = require("./connectors/FsStorage");
+const types_1 = require("../types");
+const FsHosting_1 = require("./connectors/FsHosting");
+class ServerConfig extends silex_plugins_1.Config {
+    expressOptions = {
+        jsonLimit: process.env.SILEX_EXPRESS_JSON_LIMIT,
+        textLimit: process.env.SILEX_EXPRESS_TEXT_LIMIT,
+        urlencodedLimit: process.env.SILEX_EXPRESS_URLENCODED_LIMIT,
+        sessionName: process.env.SILEX_SESSION_NAME,
+        sessionSecret: process.env.SILEX_SESSION_SECRET,
+        cors: process.env.SILEX_CORS_URL,
+    };
+    port = process.env.SILEX_PORT;
+    debug = process.env.SILEX_DEBUG === 'true';
+    url = process.env.SILEX_URL?.replace(/\/$/, '') ?? `${process.env.SILEX_PROTOCOL}://${process.env.SILEX_HOST}:${process.env.SILEX_PORT}`;
+    userConfigPath = process.env.SILEX_CONFIG;
+    configFilePath = (0, path_1.resolve)(__dirname, '../../../.silex.js');
+    getConnectors(type = null) {
+        if (!type) {
+            const allConnectors = this.getStorageConnectors().concat(this.getHostingConnectors());
+            return [...new Set(allConnectors)];
+        }
+        const connectorType = (0, connectors_1.toConnectorEnum)(type.toString());
+        switch (connectorType) {
+            case types_1.ConnectorType.HOSTING: return this.getHostingConnectors();
+            case types_1.ConnectorType.STORAGE: return this.getStorageConnectors();
+            default: throw new Error(`Unknown connector type ${type}`);
+        }
+    }
+    storageConnectors = [];
+    addStorageConnector(storage) {
+        this.setStorageConnectors(this.storageConnectors.concat(storage));
+    }
+    setStorageConnectors(storageConnectors) {
+        this.storageConnectors = storageConnectors;
+    }
+    getStorageConnectors() {
+        return this.storageConnectors;
+    }
+    hostingConnectors = [];
+    addHostingConnector(hosting) {
+        this.setHostingConnectors(this.hostingConnectors.concat(hosting));
+    }
+    setHostingConnectors(hostings) {
+        this.hostingConnectors = hostings;
+    }
+    getHostingConnectors() { return this.hostingConnectors; }
+    async addRoutes(app) {
+        const path = process.env.SILEX_CLIENT_CONFIG;
+        if (path) {
+            console.info(`> Serving client side config ${path} at ${constants_1.CLIENT_CONFIG_FILE_NAME}`);
+            try {
+                let clientConfig = (await (0, promises_1.readFile)(path)).toString();
+                app.get(`/${constants_1.CLIENT_CONFIG_FILE_NAME}`, async (req, res) => {
+                    if (this.debug) {
+                        console.info('[Debug mode] Reloading config file', path);
+                        clientConfig = (await (0, promises_1.readFile)(path)).toString();
+                    }
+                    res
+                        .contentType('application/javascript')
+                        .send(clientConfig);
+                });
+            }
+            catch (e) {
+                console.error(`Error loading client config file ${path}`, e);
+                throw new Error(`Error loading client config file ${path}: ${e.message}`);
+            }
+        }
+    }
+    async loadConfigFiles() {
+        await this.loadUserConfig();
+        await this.loadSilexConfig();
+    }
+    async loadUserConfig() {
+        if (this.userConfigPath) {
+            console.info('> Loading user config', this.userConfigPath);
+            try {
+                await this.addPlugin(this.userConfigPath, {});
+            }
+            catch (e) {
+                throw new Error(`\nUser config file ${this.userConfigPath} error:\n\n\t${e.message}\n\n`);
+            }
+        }
+    }
+    async loadSilexConfig() {
+        console.info('> Loading config', this.configFilePath);
+        try {
+            await this.addPlugin(this.configFilePath, {});
+        }
+        catch (e) {
+            if (e.code === 'MODULE_NOT_FOUND' && (!e.requireStack || !e.requireStack.find(path => path === this.configFilePath))) {
+                console.info('> /!\\ Config file not found', this.configFilePath);
+            }
+            else {
+                throw new Error(`Error in config file ${this.configFilePath}: ${e.message}`);
+            }
+        }
+    }
+    async initDefaultConnectors() {
+        if (!this.storageConnectors.length) {
+            this.addStorageConnector(new FsStorage_1.FsStorage(null, {
+                path: process.env.SILEX_FS_ROOT,
+            }));
+        }
+        if (!this.hostingConnectors.length) {
+            this.addHostingConnector(new FsHosting_1.FsHosting(null, {
+                path: process.env.SILEX_FS_ROOT,
+            }));
+        }
+    }
+}
+exports.ServerConfig = ServerConfig;

package/dist/server/server/connectors/FsHosting.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FsHosting = void 0;
+const path_1 = require("path");
+const FsStorage_1 = require("./FsStorage");
+const types_1 = require("../../types");
+class FsHosting extends FsStorage_1.FsStorage {
+    connectorId = 'fs-hosting';
+    displayName = 'File system hosting';
+    connectorType = types_1.ConnectorType.HOSTING;
+    async publish(session, id, files, { startJob, jobSuccess, jobError }) {
+        const job = startJob(`Publishing to ${this.displayName}`);
+        job.logs = [[`Publishing to ${this.displayName}`]];
+        job.errors = [[]];
+        this.write(session, '', files, '', async ({ status, message }) => {
+            job.status = status;
+            job.message = message;
+            job.logs[0].push(message);
+            if (status === types_1.JobStatus.SUCCESS) {
+                jobSuccess(job.jobId, message);
+            }
+            else if (status === types_1.JobStatus.ERROR) {
+                job.errors[0].push(message);
+                jobError(job.jobId, message);
+            }
+        });
+        return job;
+    }
+    async getUrl(session, id) {
+        const filePath = (0, path_1.join)(this.options.path, id, 'index.html');
+        const fileUrl = new URL(filePath, 'file://');
+        return fileUrl.toString();
+    }
+}
+exports.FsHosting = FsHosting;

package/dist/server/server/connectors/FsStorage.js

@@ -0,0 +1,225 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FsStorage = void 0;
+const promises_1 = __importStar(require("fs/promises"));
+const fs_1 = require("fs");
+const connectors_1 = require("./connectors");
+const path_1 = require("path");
+const types_1 = require("../../types");
+const os_1 = require("os");
+const validation_1 = require("../utils/validation");
+const constants_1 = require("../../constants");
+const stream_1 = require("stream");
+const uuid_1 = require("uuid");
+if (!globalThis.__dirname) {
+    globalThis.__dirname = (0, path_1.dirname)(process.cwd() + '/src/ts/server/connectors/FsStorage.ts');
+    console.info('Redefining __dirname', globalThis.__dirname);
+}
+const USER_ICON = 'data:image/svg+xml,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' height=\'1em\' viewBox=\'0 0 448 512\'%3E%3Cpath d=\'M304 128a80 80 0 1 0 -160 0 80 80 0 1 0 160 0zM96 128a128 128 0 1 1 256 0A128 128 0 1 1 96 128zM49.3 464H398.7c-8.9-63.3-63.3-112-129-112H178.3c-65.7 0-120.1 48.7-129 112zM0 482.3C0 383.8 79.8 304 178.3 304h91.4C368.2 304 448 383.8 448 482.3c0 16.4-13.3 29.7-29.7 29.7H29.7C13.3 512 0 498.7 0 482.3z\'/%3E%3C/svg%3E';
+const FILE_ICON = 'data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20viewBox%3D%220%200%2024%2024%22%20fill%3D%22none%22%20stroke%3D%22currentColor%22%20stroke-width%3D%222%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%3E%3Cpath%20d%3D%22M6%202L6%2022%2018%2022%2018%207%2012%202%206%202Z%22%3E%3C%2Fpath%3E%3Cpath%20d%3D%22M18%202L12%202%2012%208%2018%208%2018%202Z%22%3E%3C%2Fpath%3E%3C%2Fsvg%3E';
+class FsStorage {
+    connectorId = 'fs-storage';
+    displayName = 'File system storage';
+    icon = FILE_ICON;
+    disableLogout = true;
+    options;
+    connectorType = types_1.ConnectorType.STORAGE;
+    color = '#ffffff';
+    background = '#006400';
+    constructor(config, opts) {
+        this.options = {
+            path: (0, path_1.join)(__dirname, '..', '..', '..', '..', 'data'),
+            assetsFolder: '/assets',
+            ...opts,
+        };
+        this.initFs();
+    }
+    async initFs() {
+        const stat = await promises_1.default.stat(this.options.path).catch(() => null);
+        if (!stat) {
+            const id = constants_1.DEFAULT_WEBSITE_ID;
+            await promises_1.default.mkdir((0, path_1.join)(this.options.path, id, this.options.assetsFolder), { recursive: true });
+            await this.setWebsiteMeta({}, id, { name: 'Default website', connectorUserSettings: {} });
+            await this.updateWebsite({}, id, types_1.defaultWebsiteData);
+        }
+    }
+    updateStatus(filesStatuses, status, statusCbk) {
+        statusCbk && statusCbk({
+            message: `<p>Writing files:<ul><li>${filesStatuses.map(({ file, message }) => `${file.path}: ${message}`).join('</li><li>')}</li></ul></p>`,
+            status,
+        });
+    }
+    initStatus(files) {
+        return files.map(file => ({
+            file,
+            message: 'Waiting',
+            status: types_1.JobStatus.IN_PROGRESS,
+        }));
+    }
+    getOptions(formData) {
+        return {};
+    }
+    async getOAuthUrl(session) { return null; }
+    async getLoginForm(session, redirectTo) {
+        return null;
+    }
+    async getSettingsForm(session, redirectTo) {
+        return null;
+    }
+    async isLoggedIn(session) {
+        return true;
+    }
+    async setToken(session, query) { }
+    async logout(session) { }
+    async getUser(session) {
+        const { username, } = (0, os_1.userInfo)();
+        return {
+            name: username,
+            picture: USER_ICON,
+            storage: await (0, connectors_1.toConnectorData)(session, this),
+        };
+    }
+    async setWebsiteMeta(session, id, data) {
+        const websiteId = (0, validation_1.requiredParam)(id, 'website id');
+        const content = JSON.stringify(data);
+        const path = (0, path_1.join)(this.options.path, id, constants_1.WEBSITE_META_DATA_FILE);
+        await promises_1.default.writeFile(path, content);
+    }
+    async getWebsiteMeta(session, id) {
+        const websiteId = (0, validation_1.requiredParam)(id, 'website id');
+        const fileStat = await (0, promises_1.stat)((0, path_1.join)(this.options.path, websiteId));
+        const path = (0, path_1.join)(this.options.path, websiteId, constants_1.WEBSITE_META_DATA_FILE);
+        const content = await promises_1.default.readFile(path);
+        const meta = await JSON.parse(content.toString());
+        return {
+            websiteId,
+            name: meta.name,
+            imageUrl: meta.imageUrl,
+            connectorUserSettings: meta.connectorUserSettings,
+            createdAt: fileStat.birthtime,
+            updatedAt: fileStat.mtime,
+        };
+    }
+    async createWebsite(session, meta) {
+        const id = (0, uuid_1.v4)();
+        await promises_1.default.mkdir((0, path_1.join)(this.options.path, id, this.options.assetsFolder), { recursive: true });
+        await this.setWebsiteMeta(session, id, meta);
+        await this.updateWebsite(session, id, types_1.defaultWebsiteData);
+        return id;
+    }
+    async readWebsite(session, websiteId) {
+        const id = (0, validation_1.requiredParam)(websiteId, 'website id');
+        const path = (0, path_1.join)(this.options.path, id, constants_1.WEBSITE_DATA_FILE);
+        const content = await promises_1.default.readFile(path);
+        return JSON.parse(content.toString());
+    }
+    async updateWebsite(session, websiteId, data) {
+        const id = (0, validation_1.requiredParam)(websiteId, 'website id');
+        const path = (0, path_1.join)(this.options.path, id, constants_1.WEBSITE_DATA_FILE);
+        await promises_1.default.writeFile(path, JSON.stringify(data));
+    }
+    async deleteWebsite(session, websiteId) {
+        const id = (0, validation_1.requiredParam)(websiteId, 'website id');
+        const path = (0, path_1.join)(this.options.path, id);
+        return promises_1.default.rmdir(path, { recursive: true });
+    }
+    async listWebsites(session) {
+        const list = await promises_1.default.readdir(this.options.path);
+        return Promise.all(list.map(async (fileName) => {
+            const websiteId = fileName;
+            return this.getWebsiteMeta(session, websiteId);
+        }));
+    }
+    async getAsset(session, id, path) {
+        const fullPath = (0, path_1.join)(this.options.path, id, this.options.assetsFolder, path);
+        const content = await promises_1.default.readFile(fullPath);
+        return { path, content };
+    }
+    async writeAssets(session, id, files, statusCbk) {
+        return this.write(session, id, files, this.options.assetsFolder, statusCbk);
+    }
+    async write(session, id, files, assetsFolder, statusCbk) {
+        const filesStatuses = this.initStatus(files);
+        let error = null;
+        for (const fileStatus of filesStatuses) {
+            const { file } = fileStatus;
+            const path = (0, path_1.join)(this.options.path, id, assetsFolder, file.path);
+            if (typeof file.content === 'string' || Buffer.isBuffer(file.content)) {
+                fileStatus.message = 'Writing';
+                this.updateStatus(filesStatuses, types_1.JobStatus.IN_PROGRESS, statusCbk);
+                try {
+                    await promises_1.default.writeFile(path, file.content, 'binary');
+                }
+                catch (err) {
+                    fileStatus.message = `Error (${err})`;
+                    this.updateStatus(filesStatuses, types_1.JobStatus.IN_PROGRESS, statusCbk);
+                    error = err;
+                    continue;
+                }
+                fileStatus.message = 'Success';
+                this.updateStatus(filesStatuses, types_1.JobStatus.IN_PROGRESS, statusCbk);
+            }
+            else if (file.content instanceof stream_1.Readable) {
+                fileStatus.message = 'Writing';
+                this.updateStatus(filesStatuses, types_1.JobStatus.IN_PROGRESS, statusCbk);
+                const writeStream = (0, fs_1.createWriteStream)(path);
+                file.content.pipe(writeStream);
+                await new Promise((resolve) => {
+                    writeStream.on('finish', () => {
+                        fileStatus.message = 'Success';
+                        this.updateStatus(filesStatuses, types_1.JobStatus.IN_PROGRESS, statusCbk);
+                        resolve(file);
+                    });
+                    writeStream.on('error', err => {
+                        console.error('writeStream error', err);
+                        fileStatus.message = `Error (${err})`;
+                        this.updateStatus(filesStatuses, types_1.JobStatus.IN_PROGRESS, statusCbk);
+                        error = err;
+                        resolve(file);
+                    });
+                });
+            }
+            else {
+                console.error('Invalid file content', typeof file.content);
+                throw new Error('Invalid file content: ' + typeof file.content);
+            }
+        }
+        this.updateStatus(filesStatuses, error ? types_1.JobStatus.ERROR : types_1.JobStatus.SUCCESS, statusCbk);
+        if (error)
+            throw error;
+    }
+    async deleteAssets(session, id, paths) {
+        for (const path of paths) {
+            await promises_1.default.unlink((0, path_1.join)(this.options.path, id, path));
+        }
+    }
+    async readAsset(session, websiteId, fileName) {
+        const id = (0, validation_1.requiredParam)(websiteId, 'website id');
+        const path = (0, path_1.join)(this.options.path, id, this.options.assetsFolder, fileName);
+        return await promises_1.default.readFile(path);
+    }
+}
+exports.FsStorage = FsStorage;

package/dist/server/server/connectors/connectors.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contentToReadable = exports.contentToBuffer = exports.contentToString = exports.toConnectorData = exports.getConnector = exports.toConnectorEnum = void 0;
+const stream_1 = require("stream");
+const types_1 = require("../../types");
+function toConnectorEnum(type) {
+    const result = types_1.ConnectorType[type.toString().toUpperCase()];
+    if (!result)
+        throw new Error(`Unknown connector type ${type}. It should be one of ${Object.keys(types_1.ConnectorType).join(', ')}`);
+    return result;
+}
+exports.toConnectorEnum = toConnectorEnum;
+async function getConnector(config, session, type, connectorId) {
+    const connectors = config.getConnectors(type);
+    if (connectorId)
+        return connectors.find(s => s.connectorId === connectorId && s.connectorType === type);
+    for (const connector of connectors) {
+        if (await connector.isLoggedIn(session)) {
+            return connector;
+        }
+    }
+    return connectors[0];
+}
+exports.getConnector = getConnector;
+async function toConnectorData(session, connector) {
+    return {
+        connectorId: connector.connectorId,
+        type: connector.connectorType,
+        displayName: connector.displayName,
+        icon: connector.icon,
+        disableLogout: !!connector.disableLogout,
+        isLoggedIn: await connector.isLoggedIn(session),
+        oauthUrl: await connector.getOAuthUrl(session),
+        color: connector.color,
+        background: connector.background,
+    };
+}
+exports.toConnectorData = toConnectorData;
+async function contentToString(content) {
+    if (typeof content === 'string')
+        return content;
+    if (Buffer.isBuffer(content))
+        return content.toString('utf8');
+    return new Promise((resolve, reject) => {
+        let result = '';
+        content.on('data', (chunk) => {
+            result += chunk.toString('utf8');
+        });
+        content.on('error', (err) => {
+            reject(err);
+        });
+        content.on('end', () => {
+            resolve(result);
+        });
+    });
+}
+exports.contentToString = contentToString;
+async function contentToBuffer(content) {
+    if (typeof content === 'string')
+        return Buffer.from(content, 'utf8');
+    if (Buffer.isBuffer(content))
+        return content;
+    if (content instanceof stream_1.Readable) {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            content.on('data', (chunk) => {
+                chunks.push(chunk);
+            });
+            content.on('error', (err) => {
+                reject(err);
+            });
+            content.on('end', () => {
+                resolve(Buffer.concat(chunks));
+            });
+        });
+    }
+    throw new Error('Unknown content type');
+}
+exports.contentToBuffer = contentToBuffer;
+function contentToReadable(content) {
+    if (typeof content === 'string')
+        return stream_1.Readable.from([content]);
+    if (Buffer.isBuffer(content))
+        return stream_1.Readable.from([content]);
+    if (content instanceof stream_1.Readable)
+        return content;
+    throw new Error('Unknown content type');
+}
+exports.contentToReadable = contentToReadable;

package/dist/server/server/events.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerEvent = void 0;
+var ServerEvent;
+(function (ServerEvent) {
+    ServerEvent["STARTUP_START"] = "startup-start";
+    ServerEvent["STARTUP_END"] = "startup-end";
+    ServerEvent["PUBLISH_START"] = "publish-start";
+    ServerEvent["PUBLISH_END"] = "publish-end";
+    ServerEvent["WEBSITE_STORE_START"] = "store-start";
+    ServerEvent["WEBSITE_STORE_END"] = "store-end";
+    ServerEvent["WEBSITE_ASSET_STORE_START"] = "asset-store-start";
+    ServerEvent["WEBSITE_ASSET_STORE_END"] = "asset-store-end";
+})(ServerEvent || (exports.ServerEvent = ServerEvent = {}));

package/dist/server/server/expose.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.events = void 0;
+exports.events = __importStar(require("./events"));

package/dist/server/server/express.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.start = exports.create = void 0;
+const express_1 = __importDefault(require("express"));
+const body_parser_1 = __importDefault(require("body-parser"));
+const compression_1 = __importDefault(require("compression"));
+const cookie_parser_1 = __importDefault(require("cookie-parser"));
+const cookie_session_1 = __importDefault(require("cookie-session"));
+const cors_1 = __importDefault(require("cors"));
+const events_1 = require("./events");
+function create(config) {
+    const app = (0, express_1.default)();
+    app.set('config', config);
+    const options = config.expressOptions;
+    if (options.cors) {
+        console.info('> CORS are ENABLED:', options.cors);
+        app.use((0, cors_1.default)({
+            origin: options.cors,
+        }));
+    }
+    app.use((0, compression_1.default)());
+    app.use(body_parser_1.default.json({ limit: options.jsonLimit }));
+    app.use(body_parser_1.default.text({ limit: options.textLimit }));
+    app.use(body_parser_1.default.urlencoded({ limit: options.urlencodedLimit }));
+    console.info('> Session name:', options.sessionName);
+    app.use((0, cookie_parser_1.default)());
+    app.use((0, cookie_session_1.default)({
+        name: options.sessionName,
+        secret: options.sessionSecret,
+    }));
+    return app;
+}
+exports.create = create;
+async function start(app) {
+    const config = app.get('config');
+    config.emit(events_1.ServerEvent.STARTUP_START, { app });
+    return new Promise((resolve, reject) => {
+        app.listen(config.port, () => {
+            config.emit(events_1.ServerEvent.STARTUP_END, { app });
+            resolve(app);
+        });
+    });
+}
+exports.start = start;