@silexlabs/silex 3.0.0-alpha.100

package/src/ts/server/api/websiteApi.ts

@@ -0,0 +1,432 @@
+/*
+ * Silex website builder, free/libre no-code tool for makers.
+ * Copyright (c) 2023 lexoyo and Silex Labs foundation
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import { Router } from 'express'
+import formidable from 'formidable'
+import PersistentFile from 'formidable/src/PersistentFile'
+import { API_WEBSITE_ASSET_READ, API_WEBSITE_ASSETS_WRITE, API_WEBSITE_READ, API_WEBSITE_WRITE, API_WEBSITE_DELETE, API_WEBSITE_META_READ, API_WEBSITE_META_WRITE, API_WEBSITE_LIST, API_WEBSITE_CREATE, API_PATH, API_WEBSITE_PATH } from '../../constants'
+import { createReadStream } from 'fs'
+import { ApiError, ApiWebsiteAssetsReadParams, ApiWebsiteAssetsReadQuery, ApiWebsiteAssetsReadResponse, ApiWebsiteAssetsWriteQuery, ApiWebsiteAssetsWriteResponse, ApiWebsiteDeleteQuery, ApiWebsiteReadQuery, ApiWebsiteReadResponse, ApiWebsiteWriteBody, ApiWebsiteWriteQuery, ConnectorId, ConnectorType, WebsiteMeta, WebsiteData, WebsiteId, ApiWebsiteListQuery, ApiWebsiteListResponse, ApiWebsiteMetaReadQuery, ApiWebsiteMetaReadResponse, ApiWebsiteMetaWriteQuery, ApiWebsiteMetaWriteBody, WebsiteMetaFileContent, ApiWebsiteMetaWriteResponse, ApiWebsiteWriteResponse, ApiWebsiteCreateQuery, ApiWebsiteCreateBody } from '../../types'
+import { ConnectorFile, ConnectorFileContent, ConnectorSession, StorageConnector, getConnector } from '../connectors/connectors'
+import { Readable } from 'stream'
+import { requiredParam } from '../utils/validation'
+import { basename } from 'path'
+import { ServerConfig } from '../config'
+import { ServerEvent, WebsiteStoreEndEventType, WebsiteStoreStartEventType, WebsiteAssetStoreStartEventType, WebsiteAssetStoreEndEventType } from '../events'
+
+/**
+ * @fileoverview Website plugin for Silex
+ * This plugin provides the website API to Silex server
+ */
+
+export default function (config: ServerConfig, opts = {}): Router {
+  // Options with defaults
+  const options = {
+    // Default constants
+    assetsPath: '/assets',
+    // Options
+    ...opts
+  }
+
+  // Create a new router
+  const router = Router()
+
+  // Load website data
+  router.get(API_WEBSITE_READ, async (req, res, next) => {
+    const query = req.query as ApiWebsiteReadQuery
+    const { websiteId, connectorId } = query
+    const session = req['session'] as ConnectorSession
+    if(!websiteId) {
+      // List websites
+      next()
+      return
+    }
+    try {
+      // Get website data
+      const websiteData: WebsiteData | Readable = await readWebsite(
+        session,
+        websiteId,
+        connectorId,
+      )
+      if (websiteData instanceof Readable) {
+        websiteData.pipe(res.type('application/json'))
+      } else {
+        res.json(websiteData as ApiWebsiteReadResponse)
+      }
+    } catch (e) {
+      if (e.httpStatusCode) {
+        res.status(e.httpStatusCode).json({ message: e.message } as ApiError)
+      } else {
+        res.status(500).json({ message: e.message } as ApiError)
+      }
+    }
+  })
+
+  // List websites
+  router.get(API_WEBSITE_LIST, async (req, res) => {
+    const query: ApiWebsiteListQuery = req.query
+    const { connectorId } = query
+    const session = req['session'] as ConnectorSession
+    try {
+      // List websites
+      const websites = await listWebsites(req['session'], query.connectorId as string | undefined)
+      res.json(websites as ApiWebsiteListResponse)
+    } catch (e) {
+      console.error('Error getting website data', e)
+      if (e.httpStatusCode) {
+        res.status(e.httpStatusCode).json({ message: e.message } as ApiError)
+      } else {
+        res.status(500).json({ message: e.message } as ApiError)
+      }
+    }
+  })
+
+  // Save website data
+  router.post(API_WEBSITE_WRITE, async (req, res) => {
+    try {
+      // Check input
+      const query: ApiWebsiteWriteQuery = req.query as any
+      const body: ApiWebsiteWriteBody = req.body
+      const websiteId= requiredParam<WebsiteId>(query.websiteId, 'Website id')
+      const websiteData = requiredParam<WebsiteData>(body, 'Website data') as WebsiteData
+      const connectorId = query.connectorId // Optional
+      // Hook to modify the website data before saving
+      config.emit(ServerEvent.WEBSITE_STORE_START, { websiteId, websiteData, connectorId } as WebsiteStoreStartEventType)
+      // Save website data
+      await writeWebsite(
+        req['session'],
+        websiteId,
+        websiteData,
+        connectorId,
+      )
+      config.emit(ServerEvent.WEBSITE_STORE_END, null as WebsiteStoreEndEventType)
+      res.status(200).json({ message: 'Website saved' } as ApiWebsiteWriteResponse)
+    } catch (e) {
+      console.error('Error saving website data', e)
+      config.emit(ServerEvent.WEBSITE_STORE_END, e as WebsiteStoreEndEventType)
+      if (e.httpStatusCode) {
+        res.status(e.httpStatusCode).json({ message: e.message } as ApiError)
+      } else {
+        res.status(500).json({ message: e.message } as ApiError)
+      }
+    }
+  })
+
+  // Create website or update website meta
+  router.put(API_WEBSITE_CREATE, async (req, res) => {
+    try {
+      // Check input
+      const session = req['session'] as ConnectorSession
+      const query: ApiWebsiteCreateQuery = req.query as any
+      const body: ApiWebsiteCreateBody = req.body
+      const websiteMeta = requiredParam<WebsiteMetaFileContent>(body, 'Website meta') as WebsiteMeta
+      const connectorId = query.connectorId
+      const connector = await getConnector<StorageConnector>(config, session, ConnectorType.STORAGE, connectorId)
+      if(!connector) {
+        throw new ApiError(`Connector ${connectorId} not found`, 500)
+      }
+      // Create website
+      await connector.createWebsite(
+        session,
+        websiteMeta,
+      )
+      res.json({ message: 'Website meta saved' } as ApiWebsiteMetaWriteResponse)
+    } catch (e) {
+      console.error('Error saving website meta', e)
+      if (e.httpStatusCode) {
+        res.status(e.httpStatusCode).json({ message: e.message } as ApiError)
+      } else {
+        res.status(500).json({ message: e.message } as ApiError)
+      }
+    }
+  })
+
+  // Update website meta
+  router.post(API_WEBSITE_META_WRITE, async (req, res) => {
+    try {
+      // Check input
+      const session = req['session'] as ConnectorSession
+      const query: ApiWebsiteMetaWriteQuery = req.query as any
+      const body: ApiWebsiteMetaWriteBody = req.body
+      const websiteId= requiredParam<WebsiteId>(query.websiteId, 'Website id')
+      const websiteMeta = requiredParam<WebsiteMetaFileContent>(body, 'Website meta') as WebsiteMeta
+      const connectorId = query.connectorId
+      const connector = await getConnector<StorageConnector>(config, session, ConnectorType.STORAGE, connectorId)
+      if(!connector) {
+        throw new ApiError(`Connector ${connectorId} not found`, 500)
+      }
+      // Update website meta
+      await connector.setWebsiteMeta(
+        session,
+        websiteId,
+        websiteMeta,
+      )
+      res.json({ message: 'Website meta saved' } as ApiWebsiteMetaWriteResponse)
+    } catch (e) {
+      console.error('Error saving website meta', e)
+      if (e.httpStatusCode) {
+        res.status(e.httpStatusCode).json({ message: e.message } as ApiError)
+      } else {
+        res.status(500).json({ message: e.message } as ApiError)
+      }
+    }
+  })
+
+  // Get website meta
+  router.get(API_WEBSITE_META_READ, async (req, res) => {
+    try {
+      const session = req['session'] as ConnectorSession
+      const query: ApiWebsiteMetaReadQuery = req.query as any
+      const websiteId= requiredParam<WebsiteId>(query.websiteId, 'Website id')
+      const connectorId = query.connectorId
+      const connector = await getConnector<StorageConnector>(config, session, ConnectorType.STORAGE, connectorId)
+      if(!connector) {
+        throw new ApiError(`Connector ${connectorId} not found`, 500)
+      }
+      const websiteMeta: WebsiteMeta = await connector.getWebsiteMeta(session, websiteId)
+      res.json(websiteMeta as ApiWebsiteMetaReadResponse)
+    } catch (e) {
+      console.error('Error getting website meta', e)
+      if (e.httpStatusCode) {
+        res.status(e.httpStatusCode).json({ message: e.message } as ApiError)
+      } else {
+        res.status(500).json({ message: e.message } as ApiError)
+      }
+    }
+  })
+
+  // Delete website
+  router.delete(API_WEBSITE_DELETE, async (req, res) => {
+    try {
+      const query: ApiWebsiteDeleteQuery = req.query as any
+      const websiteId= requiredParam<WebsiteId>(query.websiteId, 'Website id')
+      await deleteWebsite(req['session'], websiteId, query.connectorId)
+      res.status(200).json({ message: 'Website deleted' } as ApiError)
+    } catch (e) {
+      console.error('Error deleting website data', e)
+      if (e.httpStatusCode) {
+        res.status(e.httpStatusCode).json({ message: e.message } as ApiError)
+      } else {
+        res.status(500).json({ message: e.message } as ApiError)
+      }
+    }
+  })
+
+  // Load assets
+  router.get(API_WEBSITE_ASSET_READ + '/:path', async (req, res) => {
+    {
+      try {
+        const query: ApiWebsiteAssetsReadQuery = req.query as any
+        const params: ApiWebsiteAssetsReadParams = req.params as any
+        const websiteId= requiredParam<WebsiteId>(query.websiteId, 'Website id')
+        const path = requiredParam<string>(params.path, 'path')
+        const asset: ConnectorFileContent = await readAsset(req['session'], websiteId, path, query.connectorId)
+        // Set content type
+        res.contentType(basename(path))
+        // Send the file
+        if (asset instanceof Readable) {
+          // Stream
+          asset.pipe(res)
+        } else {
+          // Buffer or string
+          res.send(asset as ApiWebsiteAssetsReadResponse)
+        }
+      } catch (e) {
+        console.error('Error getting asset', e)
+        if (e.httpStatusCode) {
+          res.status(e.httpStatusCode).json({ message: e.message } as ApiError)
+        } else {
+          res.status(500).json({ message: e.message } as ApiError)
+        }
+      }
+    }
+  })
+
+  // Upload assets
+  router.post(API_WEBSITE_ASSETS_WRITE, async (req, res) => {
+    try {
+      // Check input
+      const query: ApiWebsiteAssetsWriteQuery = req.query as any
+      const websiteId= requiredParam<WebsiteId>(query.websiteId as WebsiteId, 'Website id')
+
+      // Get the file data from the request
+      const form = formidable({
+        filename: (name, ext, part, _form) => `${name}${ext}`,
+        multiples: true,
+        keepExtensions: true,
+      })
+      const connectorId = query.connectorId // Optional
+
+      // Retrive the files
+      const files: ConnectorFile[] = await new Promise<ConnectorFile[]>((resolve, reject) => {
+        form.parse(req, async (err, fields, _files) => {
+          if (err) {
+            console.error('Error parsing upload data', err)
+            reject(new ApiError('Error parsing upload data: ' + err.message, 400))
+          } else {
+            const files = ([].concat(_files['files[]']) as PersistentFile[])
+              .map(file => file.toJSON())
+              .map(file => ({
+                path: `/${file.originalFilename}`,
+                content: createReadStream(file.filepath),
+              }))
+            resolve(files)
+          }
+        })
+      })
+
+      // Hook to modify the files
+      config.emit(ServerEvent.WEBSITE_ASSET_STORE_START, { files, websiteId, connectorId } as WebsiteAssetStoreStartEventType)
+
+      // Write the files
+      const result = await writeAssets(req['session'], websiteId, files, connectorId)
+
+      // Base URL of silex serve
+      const baseUrl = new URL(config.url).pathname.replace(/\/$/, '')
+
+      // Return the file URLs to insert in the website
+      // As expected by grapesjs (https://grapesjs.com/docs/modules/Assets.html#uploading-assets)
+      const data = result.map(path =>
+        // FIXME: We should return path without this line, as it is saved, not as it is displayed
+        baseUrl + API_PATH + API_WEBSITE_PATH + API_WEBSITE_ASSET_READ
+        + path
+        + `?websiteId=${websiteId}&connectorId=${connectorId ? connectorId : ''}` // As expected by wesite API (readAsset)
+      )
+
+      // Return the file URLs
+      res.json({
+        data,
+      } as ApiWebsiteAssetsWriteResponse)
+
+      // Hook for plugins
+      config.emit(ServerEvent.WEBSITE_ASSET_STORE_END, null as WebsiteAssetStoreEndEventType)
+    } catch (e) {
+      console.error('Error uploading assets', e)
+      if (e.httpStatusCode) {
+        res.status(e.httpStatusCode).json({ message: e.message } as ApiError)
+      } else {
+        res.status(500).json({ message: e.message } as ApiError)
+      }
+      // Hook for plugins
+      config.emit(ServerEvent.WEBSITE_ASSET_STORE_END, e as WebsiteAssetStoreEndEventType)
+    }
+  })
+
+  /**
+   * Get the desired connector
+   * Can be the default connector or a specific one
+   */
+  async function getStorageConnector(session: any, connectorId?: string): Promise<StorageConnector> {
+    const storageConnector = await getConnector(config, session, ConnectorType.STORAGE, connectorId) //  ?? config.getStorageConnectors()[0]
+
+    if (!storageConnector) {
+      throw new ApiError('No storage connector found', 404)
+    }
+
+    if (!await storageConnector.isLoggedIn(session)) {
+      throw new ApiError('Not logged in', 401)
+    }
+
+    return storageConnector as StorageConnector
+  }
+
+  /**
+   * Read the website data
+   */
+  async function readWebsite(session: any, websiteId: string, connectorId?: string): Promise<WebsiteData | Readable> {
+    // Get the desired connector
+    const storageConnector = await getStorageConnector(session, connectorId)
+
+    // Return website data
+    return storageConnector.readWebsite(session, websiteId)
+  }
+
+  /**
+   * List existing websites
+   */
+  async function listWebsites(session: any, connectorId?: string): Promise<WebsiteMeta[]> {
+    // Get the desired connector
+    const storageConnector = await getStorageConnector(session, connectorId)
+
+    // List websites
+    return storageConnector.listWebsites(session)
+  }
+
+  /**
+   * Write the website data to the connector
+   */
+  async function writeWebsite(session: any, websiteId: WebsiteId, websiteData: WebsiteData, connectorId?: ConnectorId): Promise<void> {
+    // Get the desired connector
+    const storageConnector = await getStorageConnector(session, connectorId)
+
+    // Write the website data
+    await storageConnector.updateWebsite(session, websiteId, websiteData)
+  }
+
+  /**
+   * Delete a website
+   */
+  async function deleteWebsite(session: any, websiteId: string, connectorId?: string): Promise<void> {
+    // Get the desired connector
+    const storageConnector = await getStorageConnector(session, connectorId)
+
+    // Delete the website
+    return storageConnector.deleteWebsite(session, websiteId)
+  }
+
+  /**
+   * Read an asset
+   */
+  async function readAsset(session: any, websiteId: string, fileName: string, connectorId?: string): Promise<ConnectorFileContent> {
+    // Get the desired connector
+    const storageConnector = await getStorageConnector(session, connectorId)
+
+    // Read the asset from the connector
+    return storageConnector.readAsset(session, websiteId, `/${fileName}`)
+  }
+
+  /**
+   * Write an asset to the connector
+   * @returns File names on the storage connector, always starting with a slash
+   */
+  async function writeAssets(session: any, websiteId: string, files: ConnectorFile[], connectorId?: string): Promise<string[]> {
+    // Get the desired connector
+    const storageConnector = await getStorageConnector(session, connectorId)
+
+    // Clean up the path
+    const cleanPathFiles = files.map(file => ({
+      ...file,
+      path: file.path.replace('/assets/', '/'), // Remove the assets folder added by GrapesJS
+    }))
+
+    // Write the asset to the connector
+    const result = await storageConnector.writeAssets(
+      session,
+      websiteId,
+      cleanPathFiles,
+    )
+
+    // Return the files URLs with the website id
+    return files
+      // Use the original path or the one returned by the connector
+      .map(({ path }, idx) => result && result[idx] ? result[idx] : path)
+      // Make it an absolute path with the website id and the connector id as query params
+      //.map((path) => toAssetUrl(path, config.url, websiteId, connectorId))
+  }
+
+  return router
+}

package/src/ts/server/cli.ts

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+
+/*
+ * Silex website builder, free/libre no-code tool for makers.
+ * Copyright (c) 2023 lexoyo and Silex Labs foundation
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import silex from './index'
+import { parse } from 'cli'
+
+const options = 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
+
+silex()

package/src/ts/server/config.ts

@@ -0,0 +1,189 @@
+/*
+ * Silex website builder, free/libre no-code tool for makers.
+ * Copyright (c) 2023 lexoyo and Silex Labs foundation
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * @fileoverview This is where the default config is defined. Also use this object as an event emitter to listen to Silex events
+ * The values can be overriden with env vars or before passing the config to Silex
+ */
+
+/**
+ * @class default config for Silex server
+ */
+
+import { Config, Plugin } from '@silexlabs/silex-plugins'
+import { resolve } from 'path'
+import { CLIENT_CONFIG_FILE_NAME } from '../constants'
+import { Application, Request, Response, Router } from 'express'
+import { readFile } from 'fs/promises'
+import { HostingConnector, StorageConnector, toConnectorEnum } from './connectors/connectors'
+import { FsStorage } from './connectors/FsStorage'
+import { Connector } from './connectors/connectors'
+import { ConnectorType } from '../types'
+import { FsHosting } from './connectors/FsHosting'
+
+/**
+ * Config types definitions
+ */
+export class ServerConfig extends Config {
+  public 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,
+  }
+  public port = process.env.SILEX_PORT
+  public debug = process.env.SILEX_DEBUG === 'true'
+  public url = process.env.SILEX_URL?.replace(/\/$/, '') ?? `${process.env.SILEX_PROTOCOL}://${process.env.SILEX_HOST}:${process.env.SILEX_PORT}`
+  public userConfigPath: Plugin | undefined = process.env.SILEX_CONFIG
+  public configFilePath: Plugin = resolve(__dirname, '../../../.silex.js')
+
+  // All connectors or just the storage or hosting connectors
+  getConnectors(type: ConnectorType | string | null = null): Connector[] {
+    // All connectors including storage and hosting connectors
+    if (!type) {
+      // Concat storage and hosting connectors
+      const allConnectors: Connector[] = (this.getStorageConnectors() as Connector[]).concat(this.getHostingConnectors())
+
+      // Remove duplicates (if a connector is both a storage and a hosting connector)
+      return [...new Set(allConnectors)]
+    }
+
+    // Convert to enum in case it is a string
+    const connectorType = toConnectorEnum(type.toString())
+
+    // Only one type of connector
+    switch(connectorType) {
+    case ConnectorType.HOSTING: return this.getHostingConnectors()
+    case ConnectorType.STORAGE: return this.getStorageConnectors()
+    default: throw new Error(`Unknown connector type ${type}`)
+    }
+  }
+
+  // Storage connectors to store the website data and assets
+  private storageConnectors: StorageConnector[] = []
+  addStorageConnector(storage: StorageConnector | StorageConnector[]) {
+    this.setStorageConnectors(this.storageConnectors.concat(storage))
+  }
+  setStorageConnectors(storageConnectors: StorageConnector[]) {
+    this.storageConnectors =storageConnectors
+  }
+  getStorageConnectors(): StorageConnector[] {
+    return this.storageConnectors
+  }
+
+  // Hosting connectors to publish the website online
+  private hostingConnectors: HostingConnector[] = []
+  addHostingConnector(hosting: HostingConnector | HostingConnector[]) {
+    this.setHostingConnectors(this.hostingConnectors.concat(hosting))
+  }
+  setHostingConnectors(hostings: HostingConnector[]) {
+    this.hostingConnectors = hostings
+  }
+  getHostingConnectors(): HostingConnector[] { return this.hostingConnectors }
+
+  /**
+   * Add routes to serve the client config file
+   */
+  async addRoutes(app: Application) {
+    const path = process.env.SILEX_CLIENT_CONFIG
+    if (path) {
+      console.info(`> Serving client side config ${path} at ${CLIENT_CONFIG_FILE_NAME}`)
+      try {
+        // Load the client config file
+        let clientConfig = (await readFile(path as string)).toString()
+        // Serve the config file
+        app.get(`/${CLIENT_CONFIG_FILE_NAME}`, async (req: Request, res: Response) => {
+          // Reload each time in debug mode
+          if (this.debug) {
+            console.info('[Debug mode] Reloading config file', path)
+            clientConfig = (await readFile(path)).toString()
+          }
+          // Send the config file
+          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}`)
+      }
+    }
+  }
+
+  /**
+   * Load config files
+   * This is the main config file and the user config file
+   */
+  async loadConfigFiles() {
+    // Load the user config file
+    await this.loadUserConfig()
+    // Load the main config file
+    await this.loadSilexConfig()
+  }
+
+  /**
+   * Load user config file
+   * This is the config file passed as env var CONFIG
+   */
+  async loadUserConfig() {
+    if (this.userConfigPath) {
+      console.info('> Loading user config', this.userConfigPath)
+      try {
+        // Initiate the process with the config file which is just another plugin
+        await this.addPlugin(this.userConfigPath, {})
+      } catch (e) {
+        throw new Error(`\nUser config file ${this.userConfigPath} error:\n\n\t${e.message}\n\n`)
+      }
+    }
+  }
+
+  /**
+   * Load .silex.js in the root folder
+   * This is the main config file
+   */
+  async loadSilexConfig() {
+    console.info('> Loading config', this.configFilePath)
+    try {
+      // Initiate the process with the config file which is just another plugin
+      await this.addPlugin(this.configFilePath, {})
+    } catch(e) {
+      // Check if the error is about the config file not found and not another module not found in the config file
+      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() {
+    // Add default storage connectors
+    if (!this.storageConnectors.length) {
+      this.addStorageConnector(new FsStorage(null, {
+        path: process.env.SILEX_FS_ROOT,
+      }))
+    }
+    // Add default hosting connectors
+    if (!this.hostingConnectors.length) {
+      this.addHostingConnector(new FsHosting(null, {
+        path: process.env.SILEX_FS_ROOT,
+      }))
+    }
+  }
+}