@silexlabs/silex 3.0.1-alpha.0 → 3.0.1

package/dist/server/server/api/websiteApi.js

@@ -0,0 +1,315 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const express_1 = require("express");
+const formidable_1 = __importDefault(require("formidable"));
+const constants_1 = require("../../constants");
+const fs_1 = require("fs");
+const types_1 = require("../../types");
+const connectors_1 = require("../connectors/connectors");
+const stream_1 = require("stream");
+const validation_1 = require("../utils/validation");
+const path_1 = require("path");
+const events_1 = require("../events");
+function default_1(config, opts = {}) {
+    const options = {
+        assetsPath: '/assets',
+        ...opts
+    };
+    const router = (0, express_1.Router)();
+    router.get(constants_1.API_WEBSITE_READ, async (req, res, next) => {
+        const query = req.query;
+        const { websiteId, connectorId } = query;
+        const session = req['session'];
+        if (!websiteId) {
+            next();
+            return;
+        }
+        try {
+            const websiteData = await readWebsite(session, websiteId, connectorId);
+            if (websiteData instanceof stream_1.Readable) {
+                websiteData.pipe(res.type('application/json'));
+            }
+            else {
+                res.json(websiteData);
+            }
+        }
+        catch (e) {
+            if (e.httpStatusCode) {
+                res.status(e.httpStatusCode).json({ message: e.message });
+            }
+            else {
+                res.status(500).json({ message: e.message });
+            }
+        }
+    });
+    router.get(constants_1.API_WEBSITE_LIST, async (req, res) => {
+        const query = req.query;
+        const { connectorId } = query;
+        const session = req['session'];
+        try {
+            const websites = await listWebsites(req['session'], query.connectorId);
+            res.json(websites);
+        }
+        catch (e) {
+            console.error('Error getting website data', e);
+            if (e.httpStatusCode) {
+                res.status(e.httpStatusCode).json({ message: e.message });
+            }
+            else {
+                res.status(500).json({ message: e.message });
+            }
+        }
+    });
+    router.post(constants_1.API_WEBSITE_WRITE, async (req, res) => {
+        try {
+            const query = req.query;
+            const body = req.body;
+            const websiteId = (0, validation_1.requiredParam)(query.websiteId, 'Website id');
+            const websiteData = (0, validation_1.requiredParam)(body, 'Website data');
+            const connectorId = query.connectorId;
+            config.emit(events_1.ServerEvent.WEBSITE_STORE_START, { websiteId, websiteData, connectorId });
+            await writeWebsite(req['session'], websiteId, websiteData, connectorId);
+            config.emit(events_1.ServerEvent.WEBSITE_STORE_END, null);
+            res.status(200).json({ message: 'Website saved' });
+        }
+        catch (e) {
+            console.error('Error saving website data', e);
+            config.emit(events_1.ServerEvent.WEBSITE_STORE_END, e);
+            if (e.httpStatusCode) {
+                res.status(e.httpStatusCode).json({ message: e.message });
+            }
+            else {
+                res.status(500).json({ message: e.message });
+            }
+        }
+    });
+    router.put(constants_1.API_WEBSITE_CREATE, async (req, res) => {
+        try {
+            const session = req['session'];
+            const query = req.query;
+            const body = req.body;
+            const websiteMeta = (0, validation_1.requiredParam)(body, 'Website meta');
+            const connectorId = query.connectorId;
+            const connector = await (0, connectors_1.getConnector)(config, session, types_1.ConnectorType.STORAGE, connectorId);
+            if (!connector) {
+                throw new types_1.ApiError(`Connector ${connectorId} not found`, 500);
+            }
+            await connector.createWebsite(session, websiteMeta);
+            res.json({ message: 'Website meta saved' });
+        }
+        catch (e) {
+            console.error('Error saving website meta', e);
+            if (e.httpStatusCode) {
+                res.status(e.httpStatusCode).json({ message: e.message });
+            }
+            else {
+                res.status(500).json({ message: e.message });
+            }
+        }
+    });
+    router.post(constants_1.API_WEBSITE_META_WRITE, async (req, res) => {
+        try {
+            const session = req['session'];
+            const query = req.query;
+            const body = req.body;
+            const websiteId = (0, validation_1.requiredParam)(query.websiteId, 'Website id');
+            const websiteMeta = (0, validation_1.requiredParam)(body, 'Website meta');
+            const connectorId = query.connectorId;
+            const connector = await (0, connectors_1.getConnector)(config, session, types_1.ConnectorType.STORAGE, connectorId);
+            if (!connector) {
+                throw new types_1.ApiError(`Connector ${connectorId} not found`, 500);
+            }
+            await connector.setWebsiteMeta(session, websiteId, websiteMeta);
+            res.json({ message: 'Website meta saved' });
+        }
+        catch (e) {
+            console.error('Error saving website meta', e);
+            if (e.httpStatusCode) {
+                res.status(e.httpStatusCode).json({ message: e.message });
+            }
+            else {
+                res.status(500).json({ message: e.message });
+            }
+        }
+    });
+    router.get(constants_1.API_WEBSITE_META_READ, async (req, res) => {
+        try {
+            const session = req['session'];
+            const query = req.query;
+            const websiteId = (0, validation_1.requiredParam)(query.websiteId, 'Website id');
+            const connectorId = query.connectorId;
+            const connector = await (0, connectors_1.getConnector)(config, session, types_1.ConnectorType.STORAGE, connectorId);
+            if (!connector) {
+                throw new types_1.ApiError(`Connector ${connectorId} not found`, 500);
+            }
+            const websiteMeta = await connector.getWebsiteMeta(session, websiteId);
+            res.json(websiteMeta);
+        }
+        catch (e) {
+            console.error('Error getting website meta', e);
+            if (e.httpStatusCode) {
+                res.status(e.httpStatusCode).json({ message: e.message });
+            }
+            else {
+                res.status(500).json({ message: e.message });
+            }
+        }
+    });
+    router.delete(constants_1.API_WEBSITE_DELETE, async (req, res) => {
+        try {
+            const query = req.query;
+            const websiteId = (0, validation_1.requiredParam)(query.websiteId, 'Website id');
+            await deleteWebsite(req['session'], websiteId, query.connectorId);
+            res.status(200).json({ message: 'Website deleted' });
+        }
+        catch (e) {
+            console.error('Error deleting website data', e);
+            if (e.httpStatusCode) {
+                res.status(e.httpStatusCode).json({ message: e.message });
+            }
+            else {
+                res.status(500).json({ message: e.message });
+            }
+        }
+    });
+    router.post(constants_1.API_WEBSITE_DUPLICATE, async (req, res) => {
+        try {
+            const query = req.query;
+            const websiteId = (0, validation_1.requiredParam)(query.websiteId, 'New website id');
+            await duplicateWebsite(req['session'], websiteId, query.connectorId);
+            res.status(200).json({ message: 'Website duplicated' });
+        }
+        catch (e) {
+            console.error('Error duplicating website data', e);
+            if (e.httpStatusCode) {
+                res.status(e.httpStatusCode).json({ message: e.message });
+            }
+            else {
+                res.status(500).json({ message: e.message });
+            }
+        }
+    });
+    router.get(constants_1.API_WEBSITE_ASSET_READ + '/:path', async (req, res) => {
+        {
+            try {
+                const query = req.query;
+                const params = req.params;
+                const websiteId = (0, validation_1.requiredParam)(query.websiteId, 'Website id');
+                const path = (0, validation_1.requiredParam)(params.path, 'path');
+                const asset = await readAsset(req['session'], websiteId, path, query.connectorId);
+                res.contentType((0, path_1.basename)(path));
+                if (asset instanceof stream_1.Readable) {
+                    asset.pipe(res);
+                }
+                else {
+                    res.send(asset);
+                }
+            }
+            catch (e) {
+                console.error('Error getting asset', e);
+                if (e.httpStatusCode) {
+                    res.status(e.httpStatusCode).json({ message: e.message });
+                }
+                else {
+                    res.status(500).json({ message: e.message });
+                }
+            }
+        }
+    });
+    router.post(constants_1.API_WEBSITE_ASSETS_WRITE, async (req, res) => {
+        try {
+            const query = req.query;
+            const websiteId = (0, validation_1.requiredParam)(query.websiteId, 'Website id');
+            const form = (0, formidable_1.default)({
+                multiples: true,
+                keepExtensions: true,
+            });
+            const connectorId = query.connectorId;
+            const files = await new Promise((resolve, reject) => {
+                form.parse(req, async (err, fields, _files) => {
+                    if (err) {
+                        console.error('Error parsing upload data', err);
+                        reject(new types_1.ApiError('Error parsing upload data: ' + err.message, 400));
+                    }
+                    else {
+                        const files = [].concat(_files['files[]'])
+                            .map(file => file.toJSON())
+                            .map(file => ({
+                            path: `/${file.originalFilename}`,
+                            content: (0, fs_1.createReadStream)(file.filepath),
+                        }));
+                        resolve(files);
+                    }
+                });
+            });
+            config.emit(events_1.ServerEvent.WEBSITE_ASSET_STORE_START, { files, websiteId, connectorId });
+            const result = await writeAssets(req['session'], websiteId, files, connectorId);
+            const baseUrl = new URL(config.url).pathname.replace(/\/$/, '');
+            const data = result.map(path => (0, path_1.join)(baseUrl, constants_1.API_PATH, constants_1.API_WEBSITE_PATH, constants_1.API_WEBSITE_ASSET_READ, path)
+                + `?websiteId=${websiteId}&connectorId=${connectorId ? connectorId : ''}`);
+            res.json({
+                data,
+            });
+            config.emit(events_1.ServerEvent.WEBSITE_ASSET_STORE_END, null);
+        }
+        catch (e) {
+            console.error('Error uploading assets', e);
+            if (e.httpStatusCode) {
+                res.status(e.httpStatusCode).json({ message: e.message });
+            }
+            else {
+                res.status(500).json({ message: e.message });
+            }
+            config.emit(events_1.ServerEvent.WEBSITE_ASSET_STORE_END, e);
+        }
+    });
+    async function getStorageConnector(session, connectorId) {
+        const storageConnector = await (0, connectors_1.getConnector)(config, session, types_1.ConnectorType.STORAGE, connectorId);
+        if (!storageConnector) {
+            throw new types_1.ApiError('No storage connector found', 404);
+        }
+        if (!await storageConnector.isLoggedIn(session)) {
+            throw new types_1.ApiError('Not logged in', 401);
+        }
+        return storageConnector;
+    }
+    async function readWebsite(session, websiteId, connectorId) {
+        const storageConnector = await getStorageConnector(session, connectorId);
+        return storageConnector.readWebsite(session, websiteId);
+    }
+    async function listWebsites(session, connectorId) {
+        const storageConnector = await getStorageConnector(session, connectorId);
+        return storageConnector.listWebsites(session);
+    }
+    async function writeWebsite(session, websiteId, websiteData, connectorId) {
+        const storageConnector = await getStorageConnector(session, connectorId);
+        await storageConnector.updateWebsite(session, websiteId, websiteData);
+    }
+    async function deleteWebsite(session, websiteId, connectorId) {
+        const storageConnector = await getStorageConnector(session, connectorId);
+        return storageConnector.deleteWebsite(session, websiteId);
+    }
+    async function duplicateWebsite(session, websiteId, connectorId) {
+        const storageConnector = await getStorageConnector(session, connectorId);
+        return storageConnector.duplicateWebsite(session, websiteId);
+    }
+    async function readAsset(session, websiteId, fileName, connectorId) {
+        const storageConnector = await getStorageConnector(session, connectorId);
+        return storageConnector.readAsset(session, websiteId, `/${fileName}`);
+    }
+    async function writeAssets(session, websiteId, files, connectorId) {
+        const storageConnector = await getStorageConnector(session, connectorId);
+        const cleanPathFiles = files.map(file => ({
+            ...file,
+            path: file.path.replace('/assets/', '/'),
+        }));
+        const result = await storageConnector.writeAssets(session, websiteId, cleanPathFiles);
+        return files
+            .map(({ path }, idx) => result && result[idx] ? result[idx] : path);
+    }
+    return router;
+}

package/dist/server/server/cli.js

@@ -0,0 +1,71 @@
+#!/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'],
+    'server-config': ['s', 'Path for the server side config file to load at startup', 'file'],
+    'client-config': ['c', 'Path to client config file to be served on .silex-client.js', 'file'],
+    'fs-root': ['', 'Path to the root folder where to store websites. Used by the default storage connector (fs).', 'string'],
+    'fs-hosting-root': ['', 'Path to the root folder where to publish websites. Used by the default hosting connector (fs).', 'string'],
+    'session-name': ['', 'Sets the name param of the express module "cookie-session".', 'string'],
+    'session-secret': ['', '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['server-config'])
+    process.env.SILEX_SERVER_CONFIG = options['server-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['fs-hosting-root'])
+    process.env.SILEX_FS_HOSTING_ROOT = options['fs-hosting-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_SERVER_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 || (0, path_1.join)(process.cwd(), '/silex/storage'),
+            }));
+        }
+        if (!this.hostingConnectors.length) {
+            this.addHostingConnector(new FsHosting_1.FsHosting(null, {
+                path: process.env.SILEX_FS_HOSTING_ROOT || (0, path_1.join)(process.cwd(), '/silex/hosting'),
+            }));
+        }
+    }
+}
+exports.ServerConfig = ServerConfig;

package/dist/server/server/connectors/FsHosting.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.FsHosting = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+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 initFs() {
+        const stat = await promises_1.default.stat(this.options.path).catch(() => null);
+        if (!stat) {
+            await promises_1.default.mkdir((0, path_1.join)(this.options.path, 'assets'), { recursive: true });
+            await promises_1.default.mkdir((0, path_1.join)(this.options.path, 'css'), { recursive: true });
+            console.info(`> [FsHosting] Created folders assets/ and css/ in ${this.options.path}`);
+        }
+    }
+    async publish(session, id, files, { startJob, jobSuccess, jobError }) {
+        const job = startJob(`Publishing to ${this.displayName}`);
+        job.logs = [[`Publishing to ${this.displayName}`]];
+        job.errors = [[]];
+        await 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;