@silexlabs/silex 3.0.1-alpha.0 → 3.0.1

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

@@ -0,0 +1,228 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FsStorage = void 0;
+const promises_1 = __importDefault(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);
+}
+async function copyDir(src, dest) {
+    await promises_1.default.mkdir(dest, { recursive: true });
+    const entries = await promises_1.default.readdir(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = (0, path_1.join)(src, entry.name);
+        const destPath = (0, path_1.join)(dest, entry.name);
+        entry.isDirectory() ?
+            await copyDir(srcPath, destPath) :
+            await promises_1.default.copyFile(srcPath, destPath);
+    }
+}
+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 = '/assets/laptop.png';
+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);
+            console.info(`> [FsStorage] Created ${id} in ${this.options.path}`);
+        }
+    }
+    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 promises_1.default.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 duplicateWebsite(session, websiteId) {
+        const newWebsiteId = (0, uuid_1.v4)();
+        const from = (0, path_1.join)(this.options.path, websiteId);
+        const to = (0, path_1.join)(this.options.path, newWebsiteId);
+        await copyDir(from, to);
+        const meta = await this.getWebsiteMeta(session, websiteId);
+        await this.setWebsiteMeta(session, newWebsiteId, {
+            ...meta,
+            name: `${meta.name} copy`,
+        });
+    }
+    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);
+                }
+                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,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toConnectorEnum = toConnectorEnum;
+exports.getConnector = getConnector;
+exports.toConnectorData = toConnectorData;
+exports.contentToString = contentToString;
+exports.contentToBuffer = contentToBuffer;
+exports.contentToReadable = contentToReadable;
+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;
+}
+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];
+}
+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,
+    };
+}
+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);
+        });
+    });
+}
+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');
+}
+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');
+}

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,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = create;
+exports.start = start;
+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;
+}
+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);
+        });
+    });
+}

package/dist/server/server/index.js

@@ -0,0 +1,94 @@
+"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;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = silex;
+const silexApp = __importStar(require("./express"));
+const api_1 = __importDefault(require("./api/api"));
+const config_1 = require("./config");
+const dotenv_1 = __importDefault(require("dotenv"));
+const path_1 = require("path");
+const constants_1 = require("../constants");
+__exportStar(require("./expose"), exports);
+async function silex() {
+    console.info(constants_1.DEV_MESSAGE);
+    console.info(`Node version: ${process.version}`);
+    console.info(`CWD: ${process.cwd()}`);
+    const curDirEnv = dotenv_1.default.config();
+    if (curDirEnv.error) {
+        if (curDirEnv.error['code'] === 'ENOENT') {
+            console.info('> No .env file found in current directory');
+        }
+        else {
+            throw curDirEnv.error;
+        }
+    }
+    else {
+        console.info('> Env vars loaded from .env file');
+    }
+    const DEFAULT_ENV_FILE = (0, path_1.join)(__dirname, '../../../.env.default');
+    const rootDirEnv = dotenv_1.default.config({ path: DEFAULT_ENV_FILE });
+    if (rootDirEnv.error) {
+        if (rootDirEnv.error['code'] === 'ENOENT') {
+            throw new Error(`\n\nFailed to load default env vars. File not found ${DEFAULT_ENV_FILE}\n\n`);
+        }
+        else {
+            throw new Error(`\n\nFailed to load default env vars. Error in ${DEFAULT_ENV_FILE}: ${rootDirEnv.error.message}\n\n`);
+        }
+    }
+    console.info('> Default env vars loaded');
+    const config = new config_1.ServerConfig();
+    const app = silexApp.create(config);
+    await config.addRoutes(app);
+    await config.loadConfigFiles();
+    await config.initDefaultConnectors();
+    app.use('/api', (0, api_1.default)(config));
+    await silexApp.start(app);
+    console.info(`
+I'm ready, listening to port ${config.port}
+  `);
+    if (config.debug) {
+        startLiverReload();
+    }
+}
+async function startLiverReload() {
+    const { createServer } = await Promise.resolve().then(() => __importStar(require('livereload')));
+    const { resolve } = await Promise.resolve().then(() => __importStar(require('path')));
+    const dist = resolve(__dirname, '../../client');
+    const server = createServer({
+        delay: 0,
+    }, () => {
+        console.info(`\n> Debug mode\n> Live reload server is running.\n> Watching ${dist}`);
+    });
+    server.watch(dist);
+}
+if (require.main === module) {
+    silex();
+}

package/dist/server/server/jobs.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jobManager = void 0;
+exports.startJob = startJob;
+exports.getJob = getJob;
+exports.jobSuccess = jobSuccess;
+exports.jobError = jobError;
+exports.killJob = killJob;
+const types_1 = require("../types");
+const TIME_TO_KEEP_AFTER_STOP = 60 * 10 * 1000;
+const jobs = new Array();
+const timers = new WeakMap();
+const processKey = Math.ceil(Math.random() * 1000000);
+let nextJobId = 0;
+function startJob(message = '') {
+    const jobId = `${processKey}_${++nextJobId}`;
+    const job = {
+        jobId,
+        status: types_1.JobStatus.IN_PROGRESS,
+        message: message
+    };
+    jobs.push(job);
+    return job;
+}
+function getJob(id) {
+    return jobs.find(job => job.jobId === id);
+}
+function jobSuccess(id, message = '') {
+    return end(id, types_1.JobStatus.SUCCESS, message);
+}
+function jobError(id, message = '') {
+    return end(id, types_1.JobStatus.ERROR, message);
+}
+function killJob(job) {
+    clearTimeout(timers.get(job));
+    timers.delete(job);
+    jobs.splice(jobs.findIndex(j => job.jobId === j.jobId), 1);
+}
+function end(id, status, message = '') {
+    const job = getJob(id);
+    if (job) {
+        job.status = status;
+        if (message)
+            job.message = message;
+        timers.set(job, setTimeout(() => killJob(job), TIME_TO_KEEP_AFTER_STOP));
+        return true;
+    }
+    return false;
+}
+exports.jobManager = { startJob, jobSuccess, jobError };

package/dist/server/server/utils/validation.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requiredParam = requiredParam;
+function requiredParam(value, name, defaultValue) {
+    if (value === undefined) {
+        if (defaultValue !== undefined) {
+            return defaultValue;
+        }
+        const error = new Error(`Missing required parameter ${name}`);
+        console.error(`Missing required parameter ${name}`, error);
+        throw error;
+    }
+    return value;
+}

package/dist/server/types.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobStatus = exports.ConnectorType = exports.Initiator = exports.ClientSideFileType = exports.Unit = exports.defaultWebsiteData = exports.ApiError = void 0;
+class ApiError extends Error {
+    httpStatusCode;
+    constructor(message, httpStatusCode) {
+        super(message);
+        this.httpStatusCode = httpStatusCode;
+        console.info('API error', httpStatusCode, message);
+    }
+}
+exports.ApiError = ApiError;
+exports.defaultWebsiteData = {};
+var Unit;
+(function (Unit) {
+    Unit["PX"] = "px";
+})(Unit || (exports.Unit = Unit = {}));
+var ClientSideFileType;
+(function (ClientSideFileType) {
+    ClientSideFileType["HTML"] = "html";
+    ClientSideFileType["ASSET"] = "asset";
+    ClientSideFileType["CSS"] = "css";
+    ClientSideFileType["OTHER"] = "other";
+})(ClientSideFileType || (exports.ClientSideFileType = ClientSideFileType = {}));
+var Initiator;
+(function (Initiator) {
+    Initiator["HTML"] = "html";
+    Initiator["CSS"] = "css";
+})(Initiator || (exports.Initiator = Initiator = {}));
+var ConnectorType;
+(function (ConnectorType) {
+    ConnectorType["STORAGE"] = "STORAGE";
+    ConnectorType["HOSTING"] = "HOSTING";
+})(ConnectorType || (exports.ConnectorType = ConnectorType = {}));
+var JobStatus;
+(function (JobStatus) {
+    JobStatus["IN_PROGRESS"] = "IN_PROGRESS";
+    JobStatus["SUCCESS"] = "SUCCESS";
+    JobStatus["ERROR"] = "ERROR";
+})(JobStatus || (exports.JobStatus = JobStatus = {}));