@silexlabs/silex 3.0.0-alpha.100

package/dist/server/server/api/connectorApi.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const constants_1 = require("../../constants");
+const validation_1 = require("../utils/validation");
+const connectors_1 = require("../connectors/connectors");
+function default_1(config) {
+    const router = (0, express_1.Router)();
+    router.get(constants_1.API_CONNECTOR_USER, routeUser);
+    router.get(constants_1.API_CONNECTOR_LIST, routeListConnectors);
+    router.get(constants_1.API_CONNECTOR_LOGIN, routeLogin);
+    router.post(constants_1.API_CONNECTOR_LOGIN_CALLBACK, routeLoginSuccess);
+    router.get(constants_1.API_CONNECTOR_LOGIN_CALLBACK, routeLoginSuccess);
+    router.post(constants_1.API_CONNECTOR_LOGOUT, routeLogout);
+    return router;
+}
+exports.default = default_1;
+function validateStatus(status, _default = 500) {
+    if (!status) {
+        console.warn(`Status code is undefined, returning default ${_default}`);
+        return _default;
+    }
+    status = parseInt(status.toString());
+    if (status >= 100 && status < 600)
+        return status;
+    console.warn(`Invalid status code ${status}, returning default ${_default}}`);
+    return _default;
+}
+async function routeUser(req, res) {
+    try {
+        const config = (0, validation_1.requiredParam)(req.app.get('config'), 'Config object on express js APP');
+        const session = (0, validation_1.requiredParam)(req['session'], 'Session object');
+        const query = req.query;
+        const type = (0, connectors_1.toConnectorEnum)((0, validation_1.requiredParam)(query.type, 'Connector type'));
+        const connector = await (0, connectors_1.getConnector)(config, session, type, query.connectorId);
+        if (!connector) {
+            res
+                .status(500)
+                .json({
+                error: true,
+                message: `Connector not found: ${type} ${query.connectorId}`,
+            });
+            return;
+        }
+        if (!await connector.isLoggedIn(session)) {
+            res
+                .status(401)
+                .json({
+                error: true,
+                message: 'Not logged in',
+            });
+            return;
+        }
+        const user = await connector.getUser(session);
+        res.json(user);
+    }
+    catch (error) {
+        console.error('Error in the user request', error, error.code);
+        res.status(validateStatus(error?.code ?? error?.httpStatusCode, 500)).json({
+            error: true,
+            message: error.message,
+        });
+    }
+}
+async function routeListConnectors(req, res) {
+    try {
+        const config = (0, validation_1.requiredParam)(req.app.get('config'), 'Config object on express js APP');
+        const session = (0, validation_1.requiredParam)(req['session'], 'Session object');
+        const query = req.query;
+        const type = (0, connectors_1.toConnectorEnum)((0, validation_1.requiredParam)(query.type, 'Connector type'));
+        const connectors = config.getConnectors(type);
+        try {
+            const list = await Promise.all(connectors.map(async (connector) => (0, connectors_1.toConnectorData)(session, connector)));
+            res.json(list);
+        }
+        catch (error) {
+            console.error('Error while listing connectors', error);
+            res.status(validateStatus(error?.code ?? error?.httpStatusCode, 500)).json({
+                error: true,
+                message: 'Error while listing connectors: ' + error.message,
+            });
+        }
+    }
+    catch (error) {
+        console.error('Error in the list connectors request', error);
+        res.status(validateStatus(error?.code ?? error?.httpStatusCode, 400)).json({
+            error: true,
+            message: 'Error in the list connectors request: ' + error.message,
+        });
+    }
+}
+async function routeLogin(req, res) {
+    try {
+        const query = req.query;
+        const connectorId = (0, validation_1.requiredParam)(query.connectorId, 'Connector id');
+        const config = (0, validation_1.requiredParam)(req.app.get('config'), 'Config object on express js APP');
+        const type = (0, connectors_1.toConnectorEnum)((0, validation_1.requiredParam)(query.type, 'Connector type'));
+        const connector = await (0, connectors_1.getConnector)(config, req['session'], type, connectorId);
+        const session = (0, validation_1.requiredParam)(req['session'], 'Session object');
+        if (!connector)
+            throw new Error(`Connector not found ${connectorId} ${type}`);
+        if (await connector.isLoggedIn(session)) {
+            res.redirect(`${config.url}${constants_1.API_PATH}${constants_1.API_CONNECTOR_PATH}${constants_1.API_CONNECTOR_LOGIN_CALLBACK}?connectorId=${connectorId}&type=${type}`);
+            return;
+        }
+        const oauthUrl = await connector.getOAuthUrl(session);
+        if (oauthUrl) {
+            res.redirect(oauthUrl);
+        }
+        else {
+            const redirectTo = await connector.getSettingsForm(session, '') ?
+                `${config.url}${constants_1.API_PATH}${constants_1.API_CONNECTOR_PATH}${constants_1.API_CONNECTOR_SETTINGS}?connectorId=${connectorId}&type=${type}` :
+                `${config.url}${constants_1.API_PATH}${constants_1.API_CONNECTOR_PATH}${constants_1.API_CONNECTOR_LOGIN_CALLBACK}?connectorId=${connectorId}&type=${type}`;
+            res.send(await connector.getLoginForm(session, redirectTo));
+        }
+    }
+    catch (error) {
+        console.error('Error in the login request', error);
+        res.status(validateStatus(error?.code ?? error?.httpStatusCode, 400)).json({
+            error: true,
+            message: 'Error in the login request: ' + error.message,
+        });
+    }
+}
+async function routeLoginSuccess(req, res) {
+    try {
+        const query = req.query;
+        if (query.error)
+            throw new Error(query.error);
+        const body = req.body;
+        const session = (0, validation_1.requiredParam)(req['session'], 'Session object');
+        const connectorId = (0, validation_1.requiredParam)(query.connectorId, 'Connector id');
+        const config = (0, validation_1.requiredParam)(req.app.get('config'), 'Config object on express js APP');
+        const type = (0, connectors_1.toConnectorEnum)((0, validation_1.requiredParam)(query.type, 'Connector type'));
+        const connector = await (0, connectors_1.getConnector)(config, req['session'], type, connectorId);
+        if (!connector)
+            throw new Error('Connector not found ' + connectorId);
+        if (await connector.isLoggedIn(session)) {
+            console.info('User already logged in for connector ' + connectorId);
+        }
+        else {
+            await connector.setToken(session, {
+                ...query,
+                ...body,
+            });
+        }
+        res.send(getEndAuthHtml('Logged in', false, connectorId, connector.getOptions(body)));
+    }
+    catch (error) {
+        res
+            .status(validateStatus(error?.code ?? error?.httpStatusCode, 500))
+            .send(getEndAuthHtml(error.message, true));
+    }
+}
+async function routeLogout(req, res) {
+    try {
+        const query = req.query;
+        const session = (0, validation_1.requiredParam)(req['session'], 'Session object');
+        const config = (0, validation_1.requiredParam)(req.app.get('config'), 'Config object on express js APP');
+        const type = (0, connectors_1.toConnectorEnum)((0, validation_1.requiredParam)(query.type, 'Connector type'));
+        const connectorId = query.connectorId;
+        const connector = await (0, connectors_1.getConnector)(config, session, type, connectorId);
+        if (!connector)
+            throw new Error(`Connector not found ${connectorId} ${type}`);
+        try {
+            await connector.logout(session);
+            res.json({
+                error: false,
+                message: 'OK',
+            });
+        }
+        catch (error) {
+            console.error('Error while logging out', error);
+            res.status(validateStatus(error?.code ?? error?.httpStatusCode, 500)).json({
+                error: true,
+                message: 'Error while logging out: ' + error.message,
+            });
+            return;
+        }
+    }
+    catch (error) {
+        console.error('Error in the logout request', error);
+        res.status(validateStatus(error?.code ?? error?.httpStatusCode, 400)).json({
+            error: true,
+            message: 'Error in the logout request: ' + error.message,
+        });
+        return;
+    }
+}
+function getEndAuthHtml(message, error, connectorId, options) {
+    const data = {
+        type: 'login',
+        error,
+        message,
+        connectorId,
+        options,
+    };
+    return `
+    <html>
+      <head>
+        <script>
+          if(window.opener) {
+            window.opener.postMessage(${JSON.stringify(data)}, '*')
+            window.close()
+          } else {
+            window.location.href = '/'
+          }
+        </script>
+      </head>
+      <body>
+        <p>${message}</p>
+        <p>Close this window or <a href="/">go back to /</a></p>
+      </body>
+    </html>
+  `;
+}

package/dist/server/server/api/publicationApi.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStorageConnector = exports.getHostingConnector = exports.PublicationError = void 0;
+const express_1 = require("express");
+const constants_1 = require("../../constants");
+const types_1 = require("../../types");
+const connectors_1 = require("../connectors/connectors");
+const validation_1 = require("../utils/validation");
+const events_1 = require("../events");
+const jobs_1 = require("../jobs");
+class PublicationError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+    }
+}
+exports.PublicationError = PublicationError;
+const PROJECT_ROOT = require.main ? require.main.path : process.cwd();
+async function getHostingConnector(session, config, connectorId) {
+    const hostingConnector = await (0, connectors_1.getConnector)(config, session, types_1.ConnectorType.HOSTING, connectorId);
+    if (!hostingConnector) {
+        throw new PublicationError('No hosting connector found', 500);
+    }
+    if (!await hostingConnector.isLoggedIn(session)) {
+        throw new PublicationError('Not logged in', 401);
+    }
+    return hostingConnector;
+}
+exports.getHostingConnector = getHostingConnector;
+async function getStorageConnector(session, config, connectorId) {
+    const storageConnector = await (0, connectors_1.getConnector)(config, session, types_1.ConnectorType.STORAGE, connectorId);
+    if (!storageConnector) {
+        throw new PublicationError('No storage connector found', 500);
+    }
+    if (!await storageConnector.isLoggedIn(session)) {
+        throw new PublicationError('Not logged in to the storage connector', 401);
+    }
+    return storageConnector;
+}
+exports.getStorageConnector = getStorageConnector;
+function default_1(config) {
+    const router = (0, express_1.Router)();
+    router.get(constants_1.API_PUBLICATION_STATUS, async function (req, res) {
+        const query = req.query;
+        const jobId = query.jobId;
+        const job = jobId && (0, jobs_1.getJob)(jobId);
+        if (!job) {
+            console.error(`Error: job not found with id ${jobId}`);
+            res.status(404).json({
+                message: 'Error: job not found.',
+            });
+            return;
+        }
+        res.json({
+            ...job,
+            _timeout: undefined,
+        });
+    });
+    router.post(constants_1.API_PUBLICATION_PUBLISH, async function (req, res) {
+        try {
+            const query = req.query;
+            const body = req.body;
+            const websiteId = (0, validation_1.requiredParam)(query.websiteId, 'id in query');
+            const storageId = (0, validation_1.requiredParam)(query.storageId, 'storageId in query');
+            const hostingId = (0, validation_1.requiredParam)(query.hostingId, 'hostingId in query');
+            const session = (0, validation_1.requiredParam)(req['session'], 'session on express request');
+            const data = body;
+            const { files } = data;
+            if (!files) {
+                throw new PublicationError('Missing files in body', 400);
+            }
+            config.emit(events_1.ServerEvent.PUBLISH_START, data);
+            const hostingConnector = await getHostingConnector(session, config, hostingId);
+            const storage = await getStorageConnector(session, config, storageId);
+            const filesList = await Promise.all(files.map(async (file) => {
+                const prefix = constants_1.API_WEBSITE_ASSET_READ;
+                const fileWithContent = file;
+                const fileWithSrc = file;
+                if (!fileWithContent.content && !fileWithSrc.src)
+                    throw new PublicationError('Missing content or src in file', 400);
+                const src = fileWithSrc.src?.startsWith(prefix) ? fileWithSrc.src.substring(prefix.length) : fileWithSrc.src;
+                return {
+                    path: file.path,
+                    content: fileWithContent.content ??
+                        await storage.readAsset(session, websiteId, src),
+                };
+            }));
+            res.json({
+                url: await hostingConnector.getUrl(session, websiteId),
+                job: await hostingConnector.publish(session, websiteId, filesList, jobs_1.jobManager),
+            });
+        }
+        catch (err) {
+            console.error('Error publishing the website', err);
+            res
+                .status(typeof err.code === 'number' ? err.code : 500)
+                .json({
+                message: `Error publishing the website. ${err.message}`
+            });
+            config.emit(events_1.ServerEvent.PUBLISH_END, err);
+            return;
+        }
+        config.emit(events_1.ServerEvent.PUBLISH_END);
+    });
+    return router;
+}
+exports.default = default_1;

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

@@ -0,0 +1,296 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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.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)({
+                filename: (name, ext, part, _form) => `${name}${ext}`,
+                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 => 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 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;
+}
+exports.default = default_1;