@silexlabs/silex 3.0.0-alpha.100

package/src/ts/plugins/server/SslPlugin.ts

@@ -0,0 +1,84 @@
+/*
+ * 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 express from 'express'
+import { readFileSync } from 'fs'
+import { createServer } from 'https'
+import forceSSL from 'express-force-ssl'
+import { ServerEvent } from '../../server/events'
+
+// interface SslOptions {
+//   forceHttps?: boolean
+//   trustXFPHeader?: boolean
+//   privateKey?: string
+//   certificate?: string
+//   sslPort?: string
+// }
+
+export default async function(config, opts = {}) {
+  // Options with defaults
+  const options = {
+    forceHttps: process.env.SILEX_FORCE_HTTPS === 'true',
+    trustXFPHeader: process.env.SILEX_FORCE_HTTPS_TRUST_XFP_HEADER === 'true',
+    privateKey: process.env.SILEX_SSL_PRIVATE_KEY,
+    certificate: process.env.SILEX_SSL_CERTIFICATE,
+    sslPort: process.env.SSL_PORT || '443',
+    ...opts,
+  }
+
+  // Add routes on silex startup
+  config.on(ServerEvent.STARTUP_START, ({app}) => {
+    const router = express.Router()
+
+    // SSL
+    // force ssl if the env var SILEX_FORCE_HTTPS is set
+    if (options.forceHttps) {
+      console.info('> [SslPlugin] Force SSL option is enabled')
+      app.set('forceSSLOptions', {
+        trustXFPHeader: !!options.trustXFPHeader,
+      })
+      router.use(forceSSL)
+    } else {
+      console.info('> [SslPlugin] Force SSL option is disabled, env var SILEX_FORCE_HTTPS not set')
+    }
+
+    // SSL certificate
+    if (options.privateKey && options.certificate) {
+      console.info('> [SslPlugin] SSL certificate is enabled, found certificate:', options.certificate)
+      try {
+        const privateKey = readFileSync(options.privateKey).toString()
+        const certificate = readFileSync(options.certificate).toString()
+
+        const sslServerOptions = {
+          key: privateKey,
+          cert: certificate,
+          requestCert: true,
+          rejectUnauthorized: false,
+        }
+
+        createServer(sslServerOptions, this).listen(options.sslPort, () => {
+          console.info('> [SslPlugin] Listening on port ', options.sslPort)
+        })
+      } catch (e) {
+        console.error('> [SslPlugin] Load certificate failed.', e)
+      }
+    } else {
+      console.info('> [SslPlugin] Certificate disabled, env vars SILEX_SSL_CERTIFICATE and SILEX_SSL_PRIVATE_KEY not set')
+    }
+    app.use(router)
+  })
+}

package/src/ts/plugins/server/StaticPlugin.ts

@@ -0,0 +1,79 @@
+/*
+ * 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 express from 'express'
+import nodeModules from 'node_modules-path'
+import serveStatic from 'serve-static'
+import { withCache } from './Cache'
+import { join } from 'path'
+import { ServerEvent } from '../../server/events'
+
+type StaticOptions = {
+  routes: {
+    path: string
+    route: string
+  }[]
+}
+
+export default async function(config, opts = {}) {
+  // Options with defaults
+  const options: StaticOptions = {
+    routes: [
+      {
+        route: '/',
+        path: join(__dirname, '../../../../..', 'public'),
+      }, {
+        route: '/css/',
+        path: nodeModules('@fortawesome/fontawesome-free') + '/@fortawesome/fontawesome-free/css/',
+      }, {
+        route: '/webfonts/',
+        path: nodeModules('@fortawesome/fontawesome-free') + '/@fortawesome/fontawesome-free/webfonts/',
+      }, {
+        route: '/css/files/',
+        path: nodeModules('@fontsource/ubuntu') + '/@fontsource/ubuntu/files/',
+      //}, {
+      //  route: '/node_modules/',
+      //  path: nodeModules(),
+      }, {
+        route: '/',
+        path: join(__dirname, '../../../../..', 'dist', 'client'),
+      }, {
+        route: '/',
+        path: join(__dirname, '../../../../..', 'dist', 'plugins', 'client'),
+      },
+    ]
+    // add project route for source maps
+      .concat(config.debug ? [{
+        route: '/',
+        path: './',
+      }] : []),
+    ...opts,
+  }
+  console.info('> [StaticPlugin] Serving static files')
+
+  config.on(ServerEvent.STARTUP_START, ({app}) => {
+    const router = express.Router()
+    options.routes
+      .forEach(folder => {
+        if (!folder.route) throw new Error('The config for static module has no `route` attribute')
+        if (!folder.path) throw new Error('The config for static module has no `path` attribute')
+        console.info(`> [StaticPlugin] Serving static files from ${folder.path} on ${folder.route}`)
+        router.use(folder.route, serveStatic(folder.path))
+      })
+    app.use(withCache,  router)
+  })
+}

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

@@ -0,0 +1,19 @@
+import { Router } from 'express'
+import { ServerConfig } from '../config'
+import { noCache } from '../../plugins/server/Cache'
+
+import connectorApi from './connectorApi'
+import websiteApi from './websiteApi'
+import publicationApi from './publicationApi'
+import { API_CONNECTOR_PATH, API_PUBLICATION_PATH, API_WEBSITE_PATH } from '../../constants'
+
+export default function(config: ServerConfig): Router {
+  const router = Router()
+  router.use(noCache)
+
+  router.use(API_CONNECTOR_PATH, connectorApi(config))
+  router.use(API_WEBSITE_PATH, websiteApi(config))
+  router.use(API_PUBLICATION_PATH, publicationApi(config))
+
+  return router
+}

package/src/ts/server/api/connectorApi.ts

@@ -0,0 +1,345 @@
+import { Request, Response, Router } from 'express'
+import { API_CONNECTOR_LIST, API_CONNECTOR_LOGIN_CALLBACK, API_CONNECTOR_USER, API_CONNECTOR_LOGOUT, API_CONNECTOR_LOGIN, API_CONNECTOR_SETTINGS, API_PATH, API_CONNECTOR_PATH } from '../../constants'
+import { ServerConfig } from '../config'
+import { requiredParam } from '../utils/validation'
+import { Connector, getConnector, toConnectorData, toConnectorEnum } from '../connectors/connectors'
+import { ApiConnectorListQuery, ApiConnectorListResponse, ApiConnectorLoggedInPostMessage, ApiConnectorLoginQuery, ApiConnectorUserQuery, ApiConnectorUserResponse, ApiConnectorLogoutQuery, ConnectorId, ApiConnectorLoginCbkQuery, ApiConnectorLoginCbkBody, ConnectorOptions, ApiResponseError } from '../../types'
+
+/**
+ * @fileoverview The connector API adds routes to handle the connectors and the methods they implement, this includes authentication and user data.
+ *
+ * About authentication
+ *
+ * There are 2 types of connectors, for storage of website data and for publication to a hosting service. The authentication process is the same for both types of connectors
+ *
+ * Here is a typical authentication flow, which can be for a storage or a publication connector:
+ *
+ * 1. Client app calls the `user` route which returns a 401 as there is no auth in the session
+ * 1. Client app lists all connectors (either for publication or storage) and display a button for each connector
+ * 1. The user clicks a button, it opens a page with either the connector's `getOAuthUrl` for OAuth connectors (A) or the login route for basic auth connectors (B). This can be done in a popup (C) or as a redirect in the client app window (D)
+ * 1. OAuth (A): the page displays the OAuth page which ends up going back to the callback page
+ * 1. Basic auth (B): the page displays the login form `connector.getLoginForm()` which ends up going back to the callback page
+ * 1. The callback page stores the auth data in the session (for storage), or in the website publication settings (for publication)
+ * 1. Popup (C): The callback page will post a message to the parent window which closes the popup and goes on with the flow
+ * 1. Redirect (D): The callback page will redirect to the client app
+ * 1. The client side will call the `user` route again, which will return the user data
+ *
+ */
+/**
+ * Add routes to the express app
+ */
+export default function(config: ServerConfig) {
+  // Create the router
+  const router = Router()
+
+  // Connector routes
+  router.get(API_CONNECTOR_USER, routeUser)
+  router.get(API_CONNECTOR_LIST, routeListConnectors)
+  router.get(API_CONNECTOR_LOGIN, routeLogin)
+  // router.get(API_CONNECTOR_SETTINGS, routeSettings)
+  // router.post(API_CONNECTOR_SETTINGS, routeSettingsPost)
+  router.post(API_CONNECTOR_LOGIN_CALLBACK, routeLoginSuccess)
+  router.get(API_CONNECTOR_LOGIN_CALLBACK, routeLoginSuccess)
+  router.post(API_CONNECTOR_LOGOUT, routeLogout)
+
+  return router
+}
+
+/**
+ * Method to validate HTTP status codes
+ * Returns a suitable error code if it is not valid
+ */
+function validateStatus(status: number, _default = 500): number {
+  if(!status) {
+    console.warn(`Status code is undefined, returning default ${_default}`)
+    return _default
+  }
+  // Make sure it is a string
+  status = parseInt(status.toString())
+  // Check the status code
+  if (status >= 100 && status < 600) return status
+  // Invalid status code
+  console.warn(`Invalid status code ${status}, returning default ${_default}}`)
+  return _default
+}
+
+/**
+ * Express route to check if the user is logged in
+ * Returns user data and connector data
+ */
+async function routeUser(req: Request, res: Response) {
+  try {
+    const config = requiredParam(req.app.get('config') as ServerConfig, 'Config object on express js APP')
+    const session = requiredParam(req['session'], 'Session object')
+    const query = req.query as ApiConnectorUserQuery
+    const type = toConnectorEnum(requiredParam(query.type, 'Connector type'))
+    const connector = await getConnector<Connector>(config, session, type, query.connectorId)
+    if (!connector) {
+      res
+        .status(500)
+        .json({
+          error: true,
+          message: `Connector not found: ${type} ${query.connectorId}`,
+        } as ApiResponseError)
+      return
+    }
+    if(!await connector.isLoggedIn(session)) {
+      res
+        .status(401)
+        .json({
+          error: true,
+          message: 'Not logged in',
+        } as ApiResponseError)
+      return
+    }
+    // User logged in, return user data
+    const user = await connector.getUser(session)
+    res.json(user as ApiConnectorUserResponse)
+  } 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,
+    } as ApiResponseError)
+  }
+}
+
+/**
+ * Express route to list the connectors
+ */
+async function routeListConnectors(req: Request, res: Response) {
+  try {
+    const config = requiredParam(req.app.get('config') as ServerConfig, 'Config object on express js APP')
+    const session = requiredParam(req['session'], 'Session object')
+    const query = req.query as ApiConnectorListQuery
+    const type = toConnectorEnum(requiredParam(query.type, 'Connector type'))
+    const connectors = config.getConnectors(type)
+    try {
+      const list = await Promise.all(connectors.map(async connector => toConnectorData(session, connector)))
+      res.json(list as ApiConnectorListResponse)
+    } 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,
+      } as ApiResponseError)
+    }
+  } 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,
+    } as ApiResponseError)
+  }
+}
+
+/**
+ * Route login
+ * Display the connector's login form if the connector is basic auth
+ *   or redirect to oauth url if the connector is oauth
+ *   or redirect to success page if the user is logged in
+ */
+async function routeLogin(req: Request, res: Response) {
+  try {
+    const query = req.query as ApiConnectorLoginQuery
+    const connectorId = requiredParam(query.connectorId, 'Connector id')
+    const config = requiredParam(req.app.get('config') as ServerConfig, 'Config object on express js APP')
+    const type = toConnectorEnum(requiredParam(query.type, 'Connector type'))
+    const connector = await getConnector<Connector>(config, req['session'], type, connectorId)
+    const session = requiredParam(req['session'], 'Session object')
+    if (!connector) throw new Error(`Connector not found ${connectorId} ${type}`)
+    // Check if the user is already logged in
+    if (await connector.isLoggedIn(session)) {
+      res.redirect(`${config.url}${API_PATH}${API_CONNECTOR_PATH}${API_CONNECTOR_LOGIN_CALLBACK}?connectorId=${connectorId}&type=${type}`)
+      return
+    }
+    const oauthUrl = await connector.getOAuthUrl(session)
+    if (oauthUrl) {
+      // Starts the OAuth flow
+      res.redirect(oauthUrl)
+    } else {
+      // Display the login form
+      const redirectTo = await connector.getSettingsForm(session, '') ?
+        `${config.url}${API_PATH}${API_CONNECTOR_PATH}${API_CONNECTOR_SETTINGS}?connectorId=${connectorId}&type=${type}` :
+        `${config.url}${API_PATH}${API_CONNECTOR_PATH}${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,
+    } as ApiResponseError)
+  }
+}
+
+// /**
+//  * Route connector settings
+//  * Display the connector's settings form or redirect to login page if the user is not logged in
+//  */
+// function routeSettings(req: Request, res: Response) {
+//   try {
+//     const query = req.query as ApiConnectorSettingsQuery
+//
+//     const connectorId = requiredParam(query.connectorId, 'Connector id')
+//     const config = requiredParam(req.app.get('config') as ServerConfig, 'Config object on express js APP')
+//     const type = toConnectorEnum(requiredParam(query.type, 'Connector type'))
+//     const connector = await getConnector<Connector>(config, req['session'], type, connectorId)
+//     const session = requiredParam(req['session'], 'Session object')
+//     if (!connector) throw new Error(`Connector not found ${connectorId} ${type}`)
+//     // Check if the user is already logged in
+//     if (!await connector.isLoggedIn(session)) {
+//       res.redirect(`${config.url}${API_PATH}${API_CONNECTOR_PATH}${API_CONNECTOR_LOGIN_CALLBACK}?connectorId=${connectorId}&type=${type}&error=Not logged in`)
+//       return
+//     }
+//     // Display the login form
+//     res.send(await connector.getSettingsForm(session, ``) as ApiConnectorSettingsResponse)
+//   } catch (error) {
+//     console.error('Error in the login request', error)
+//     res.status(error?.code ?? error?.httpStatusCode ?? 400).json({
+//       error: true,
+//       message: 'Error in the login request: ' + error.message,
+//     } as ApiError)
+//   }
+// }
+//
+// /**
+//  * Route connector settings post
+//  * Save the connector's settings in the website meta file
+//  */
+// function routeSettingsPost(req: Request, res: Response) {
+//   try {
+//     const query = req.query as ApiConnectorSettingsPostQuery
+//
+//     const connectorId = requiredParam(query.connectorId, 'Connector id')
+//     const config = requiredParam(req.app.get('config') as ServerConfig, 'Config object on express js APP')
+//     const type = toConnectorEnum(requiredParam(query.type, 'Connector type'))
+//     const connector = await getConnector<Connector>(config, req['session'], type, connectorId)
+//     const session = requiredParam(req['session'], 'Session object')
+//     const body = req.body as ApiConnectorSettingsPostBody
+//     if (!connector) throw new Error(`Connector not found ${connectorId} ${type}`)
+//     // Check if the user is already logged in
+//     if (!await connector.isLoggedIn(session)) {
+//       res.redirect(`${config.url}${API_PATH}${API_CONNECTOR_PATH}${API_CONNECTOR_LOGIN_CALLBACK}?connectorId=${connectorId}&type=${type}&error=Not logged in`)
+//       return
+//     }
+//     // Save the settings
+//     await connector.setWebsiteMeta(session, websiteId, body)
+//   } catch (error) {
+//     console.error('Error in the login request', error)
+//     res.status(error?.code ?? error?.httpStatusCode ?? 400).json({
+//       error: true,
+//       message: 'Error in the login request: ' + error.message,
+//     } as ApiResponseError)
+//   }
+// }
+
+/**
+ * Express route to serve as redirect after a successful login
+ * The returned HTML will postMessage data and close the popup window
+ */
+async function routeLoginSuccess(req: Request, res: Response) {
+  try {
+    const query = req.query as ApiConnectorLoginCbkQuery
+    if(query.error) throw new Error(query.error)
+
+    const body = req.body as ApiConnectorLoginCbkBody
+    const session = requiredParam(req['session'], 'Session object')
+
+    const connectorId = requiredParam(query.connectorId, 'Connector id')
+    const config = requiredParam(req.app.get('config') as ServerConfig, 'Config object on express js APP')
+    const type = toConnectorEnum(requiredParam(query.type, 'Connector type'))
+    const connector = await getConnector<Connector>(config, req['session'], type, connectorId)
+    if (!connector) throw new Error('Connector not found ' + connectorId)
+    // Check if the user is already logged in
+    if (await connector.isLoggedIn(session)) {
+      console.info('User already logged in for connector ' + connectorId)
+    } else {
+      // Store the auth info in the session
+      // This is useful for storage only
+      await connector.setToken(session, {
+        ...query,
+        ...body,
+      })
+    }
+    // End the auth flow
+    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))
+  }
+}
+
+/**
+ * Express route to logout from a connector
+*/
+async function routeLogout(req: Request, res: Response) {
+  try {
+    const query = req.query as ApiConnectorLogoutQuery
+    const session = requiredParam(req['session'], 'Session object')
+    // Get the connector
+    const config = requiredParam(req.app.get('config') as ServerConfig, 'Config object on express js APP')
+    const type = toConnectorEnum(requiredParam(query.type, 'Connector type'))
+    const connectorId = query.connectorId
+    const connector = await getConnector<Connector>(config, session, type, connectorId)
+    if (!connector) throw new Error(`Connector not found ${connectorId} ${type}`)
+    try {
+      // Logout
+      await connector.logout(session)
+      // Return success
+      res.json({
+        error: false,
+        message: 'OK',
+      } as ApiResponseError)
+    } 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,
+      } as ApiResponseError)
+      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,
+    } as ApiResponseError)
+    return
+  }
+}
+
+/**
+ * Utility function to send an HTML page to the browser
+ * is page will send a postMessage to the parent window and close itself
+ */
+function getEndAuthHtml(message: string, error: boolean, connectorId?: ConnectorId, options?: ConnectorOptions): string {
+  // Data for postMessage
+  const data = {
+    type: 'login', // For postMessage
+    error,
+    message,
+    connectorId,
+    options,
+  } as ApiConnectorLoggedInPostMessage
+  // Send the HTML
+  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/src/ts/server/api/publicationApi.ts

@@ -0,0 +1,159 @@
+/*
+ * 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 { API_PUBLICATION_PUBLISH, API_PUBLICATION_STATUS, API_WEBSITE_ASSET_READ } from '../../constants'
+import { ApiPublicationPublishBody, ApiPublicationPublishQuery, ApiPublicationPublishResponse, ApiPublicationStatusQuery, ApiPublicationStatusResponse, JobId, PublicationData, ConnectorType, ConnectorId, WebsiteId, ClientSideFile, ClientSideFileWithContent, ClientSideFileWithSrc} from '../../types'
+import { ConnectorFile, HostingConnector, StorageConnector, getConnector } from '../connectors/connectors'
+import { ServerConfig } from '../config'
+import { requiredParam } from '../utils/validation'
+import { PublishEndEventType, PublishStartEventType, ServerEvent } from '../events'
+import { getJob, jobManager } from '../jobs'
+
+/**
+ * @fileoverview Publication plugin for Silex
+ * Adds a publication API to Silex server
+ */
+
+/**
+ * Error thrown by the publication API
+ * @param message error message
+ * @param code http status code
+ */
+export class PublicationError extends Error {
+  constructor(message: string, public code: number) {
+    super(message)
+  }
+}
+
+const PROJECT_ROOT = require.main ? require.main.path : process.cwd()
+
+/**
+ * Get the desired connector
+ * Can be the default connector or a specific one
+ */
+export async function getHostingConnector(session: any, config: ServerConfig, connectorId?: string): Promise<HostingConnector> {
+  const hostingConnector = await getConnector(config, session, ConnectorType.HOSTING, connectorId) //  ?? config.getHostingConnectors()[0]
+
+  if (!hostingConnector) {
+    throw new PublicationError('No hosting connector found', 500)
+  }
+
+  if (!await hostingConnector.isLoggedIn(session)) {
+    throw new PublicationError('Not logged in', 401)
+  }
+
+  return hostingConnector as HostingConnector
+}
+
+export async function getStorageConnector(session: any, config: ServerConfig, connectorId?: string): Promise<StorageConnector> {
+  const storageConnector = await getConnector(config, session, ConnectorType.STORAGE, connectorId) //  ?? config.getStorageConnectors()[0]
+
+  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 as StorageConnector
+}
+
+export default function (config: ServerConfig): Router {
+  // Create a new router
+  const router = Router()
+
+  // Get publication status
+  router.get(API_PUBLICATION_STATUS, async function (req, res) {
+    const query: ApiPublicationStatusQuery = req.query as any
+    const jobId: JobId = query.jobId as string
+    const job = jobId && 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,
+    } as ApiPublicationStatusResponse)
+  })
+
+  // Publish website
+  router.post(API_PUBLICATION_PUBLISH, async function (req, res) {
+    try {
+      const query: ApiPublicationPublishQuery = req.query as any
+      const body: ApiPublicationPublishBody = req.body
+      const websiteId = requiredParam<WebsiteId>(query.websiteId as string, 'id in query')
+      const storageId = requiredParam<ConnectorId>(query.storageId as string, 'storageId in query')
+      const hostingId = requiredParam<ConnectorId>(query.hostingId as string, 'hostingId in query')
+      const session = requiredParam(req['session'], 'session on express request')
+
+      // Check params
+      const data = body as PublicationData
+      const { files } = data
+      if(!files) {
+        throw new PublicationError('Missing files in body', 400)
+      }
+
+      // Hook for plugins
+      config.emit(ServerEvent.PUBLISH_START, data as PublishStartEventType)
+
+      // Get hosting connector and make sure the user is logged in
+      const hostingConnector = await getHostingConnector(session, config, hostingId)
+
+      // Get storage connector which holds the assets
+      const storage = await getStorageConnector(session, config, storageId)
+
+      // Load the content if necessary
+      const filesList: ConnectorFile[] = await Promise.all(files.map(async (file: ClientSideFile) => {
+        const prefix = API_WEBSITE_ASSET_READ
+        const fileWithContent = file as ClientSideFileWithContent
+        const fileWithSrc = file as ClientSideFileWithSrc
+        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, jobManager),
+      } as ApiPublicationPublishResponse)
+    } 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}`
+        })
+      // Hook for plugins
+      config.emit(ServerEvent.PUBLISH_END, err as PublishEndEventType)
+      return
+    }
+    // Hook for plugins
+    config.emit(ServerEvent.PUBLISH_END)
+  })
+
+  return router
+}