@silexlabs/silex 3.0.1-alpha.0 → 3.0.2

package/src/ts/server/config.ts

@@ -1,3 +1,20 @@
+/*
+ * 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
@@ -8,84 +25,165 @@
  */
 
 import { Config, Plugin } from '@silexlabs/silex-plugins'
-import { resolve } from 'path'
+import { join, resolve } from 'path'
 import { CLIENT_CONFIG_FILE_NAME } from '../constants'
-import { Router } from 'express'
+import { Application, Request, Response, Router } from 'express'
 import { readFile } from 'fs/promises'
-import { EVENT_STARTUP_START } from '../events'
+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 {
-  constructor(
-    public url: string,
-    public debug: boolean,
-    public port: string,
-    public apiPath: string,
-  ) {
-    super()
+  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_SERVER_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)]
+    }
 
-// Get config async function
-export default async function(): Promise<ServerConfig> {
-  const port = process.env.PORT || '6805' // 6805 is the date of sexual revolution started in paris france 8-)
-  const debug = process.env.SILEX_DEBUG === 'true'
-  const clientConfigPath = process.env.SILEX_CLIENT_CONFIG
+    // Convert to enum in case it is a string
+    const connectorType = toConnectorEnum(type.toString())
 
-  const url = process.env.SERVER_URL || `http://localhost:${port}`
-  const config = new ServerConfig(url, debug, port, '/api')
+    // 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}`)
+    }
+  }
 
-  // Serve the client side config file
-  if (clientConfigPath) {
-    config.on(EVENT_STARTUP_START, async ({ app }) => {
-      console.log(`> Serving client side config ${clientConfigPath} at ${CLIENT_CONFIG_FILE_NAME}`)
-      // Attach the route immediately
-      const router = Router()
-      app.use(router)
-      // Load the config file and serve it
-      let clientConfig = (await readFile(clientConfigPath as string)).toString()
-      router.get(`/${CLIENT_CONFIG_FILE_NAME}`, async (res, req, next) => {
-        // Reload each time in debug mode
-        if (config.debug) {
-          console.log('[Debug mode] Reloading config file', clientConfigPath)
-          clientConfig = (await readFile(clientConfigPath)).toString()
-        }
-        // Send the config file
-        req.header('Content-Type', 'application/javascript').send(clientConfig)
-      })
-    })
+  // 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
   }
 
-  // Optional config file
-  // Load this config file before the main config file so that routes can be overriden
-  // Or listen for event silex:startup:end to add routes after the default ones
-  if (process.env.CONFIG) {
-    const userConfigPath: Plugin = process.env.CONFIG
-    console.log('> Loading user config', userConfigPath)
+  // 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 config.addPlugin(userConfigPath, {})
-    } catch (e) {
-      throw new Error(`User config file ${userConfigPath} error: ${e.message}`)
+      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}`)
+      }
     }
   }
 
-  // Config file in root folder
-  const configFilePath: Plugin = resolve(__dirname, '../../.silex.js')
-  console.log('> Loading config', configFilePath)
-  try {
-    // Initiate the process with the config file which is just another plugin
-    await config.addPlugin(configFilePath, {})
-  } catch(e) {
-    if(e.code === 'MODULE_NOT_FOUND') {
-      console.info('No config found', configFilePath)
-    } else {
-      throw new Error(`Error in config file ${configFilePath}: ${e.message}`)
+  async initDefaultConnectors() {
+    // Add default storage connectors
+    if (!this.storageConnectors.length) {
+      this.addStorageConnector(new FsStorage(null, {
+        path: process.env.SILEX_FS_ROOT || join(process.cwd(), '/silex/storage'),
+      }))
+    }
+    // Add default hosting connectors
+    if (!this.hostingConnectors.length) {
+      this.addHostingConnector(new FsHosting(null, {
+        path: process.env.SILEX_FS_HOSTING_ROOT || join(process.cwd(), '/silex/hosting'),
+      }))
     }
   }
-
-  // Return the config file
-  return config
 }

package/src/ts/server/connectors/FsHosting.ts

@@ -0,0 +1,66 @@
+/*
+ * 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 fs from 'fs/promises'
+import { ConnectorFile, StorageConnector, HostingConnector, StatusCallback, ConnectorSession, contentToString, toConnectorData, ConnectorFileContent} from './connectors'
+import { join } from 'path'
+import { FsStorage } from './FsStorage'
+import { ConnectorType, JobData, JobStatus, PublicationJobData, WebsiteId } from '../../types'
+import { JobManager } from '../jobs'
+
+type FsSession = ConnectorSession
+
+export class FsHosting extends FsStorage implements HostingConnector<FsSession> {
+  connectorId = 'fs-hosting'
+  displayName = 'File system hosting'
+  connectorType = ConnectorType.HOSTING
+
+  protected async initFs() {
+    const stat = await fs.stat(this.options.path).catch(() => null)
+    if (!stat) {
+      await fs.mkdir(join(this.options.path, 'assets'), { recursive: true })
+      await fs.mkdir(join(this.options.path, 'css'), { recursive: true })
+      console.info(`> [FsHosting] Created folders assets/ and css/ in ${this.options.path}`)
+    }
+  }
+
+  async publish(session: FsSession, id: WebsiteId, files: ConnectorFile[], {startJob, jobSuccess, jobError}: JobManager): Promise<JobData> {
+    const job = startJob(`Publishing to ${this.displayName}`) as PublicationJobData
+    job.logs = [[`Publishing to ${this.displayName}`]]
+    job.errors = [[]]
+    // Call write without id or folder so that it goes in / (path will be modified by publication transformers)
+    await this.write(session, '', files, '', async ({status, message}) => {
+      // Update the job status
+      job.status = status
+      job.message = message
+      job.logs[0].push(message)
+      if(status === JobStatus.SUCCESS) {
+        jobSuccess(job.jobId, message)
+      } else if(status === JobStatus.ERROR) {
+        job.errors[0].push(message)
+        jobError(job.jobId, message)
+      }
+    })
+    return job
+  }
+
+  async getUrl(session: FsSession, id: WebsiteId): Promise<string> {
+    const filePath = join(this.options.path, id, 'index.html')
+    const fileUrl = new URL(filePath, 'file://')
+    return fileUrl.toString()
+  }
+}

package/src/ts/server/connectors/FsStorage.test.ts

@@ -0,0 +1,51 @@
+import { expect, beforeEach, afterAll, it, describe } from '@jest/globals'
+import { ServerConfig } from '../config'
+import { FsStorage } from './FsStorage'
+import { readFileSync, rmdirSync, statSync } from 'fs'
+import { join } from 'path'
+
+const storageRootPath = '/tmp/silex-tests'
+const assetsFolder = 'assets'
+const dummySession = {}
+const dummyId = 'dummy id'
+const dummyWebsite = {
+  pages: [],
+  assets: [],
+  styles: [],
+  settings: {},
+  fonts: [],
+  symbols: [],
+  publication: {},
+}
+
+beforeEach(() => {
+})
+
+afterAll(() => {
+  rmdirSync(storageRootPath, { recursive: true })
+})
+
+async function sleep(ms: number) {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}
+describe('FsStorage website', () => {
+  it('should create the root folder', async () => {
+    expect(() => statSync(storageRootPath)).toThrow()
+    const connector = new FsStorage({} as ServerConfig, {
+      path: storageRootPath,
+      assetsFolder,
+    })
+    await sleep(100)
+    expect(() => statSync(storageRootPath)).not.toThrow()
+  })
+  it('should create a new website', async () => {
+    const connector = new FsStorage({} as ServerConfig, {
+      path: storageRootPath,
+      assetsFolder,
+    })
+    const id = await connector.createWebsite(dummySession, { name: 'dummy name', connectorUserSettings: {} })
+    expect(id).toBeDefined()
+    expect(() => statSync(join(storageRootPath, id, 'website.json'))).not.toThrow()
+    expect(readFileSync(join(storageRootPath, id, 'website.json'), 'utf8')).toBe(JSON.stringify({}))
+  })
+})

package/src/ts/server/connectors/FsStorage.ts

@@ -0,0 +1,290 @@
+/*
+ * 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 fs from 'fs/promises'
+import { createWriteStream } from 'fs'
+import { ConnectorFile, StorageConnector, StatusCallback, ConnectorSession, toConnectorData, ConnectorFileContent} from './connectors'
+import { dirname, join } from 'path'
+import { ConnectorUser, WebsiteMeta, JobStatus, WebsiteId, ConnectorType, WebsiteMetaFileContent, WebsiteData, defaultWebsiteData, ConnectorOptions } from '../../types'
+import { userInfo } from 'os'
+import { requiredParam } from '../utils/validation'
+import { ServerConfig } from '../config'
+import { DEFAULT_WEBSITE_ID, WEBSITE_DATA_FILE, WEBSITE_META_DATA_FILE } from '../../constants'
+import { Readable } from 'stream'
+import { v4 as uuid } from 'uuid'
+import { fileURLToPath } from 'url'
+
+// Variables needed for jest tests
+if(!globalThis.__dirname) {
+  // @ts-ignore
+  globalThis.__dirname = dirname(process.cwd() + '/src/ts/server/connectors/FsStorage.ts')
+  console.info('Redefining __dirname', globalThis.__dirname)
+}
+
+// Copy a folder recursively
+async function copyDir(src, dest) {
+  await fs.mkdir(dest, { recursive: true })
+  const entries = await fs.readdir(src, { withFileTypes: true })
+
+  for (const entry of entries) {
+    const srcPath = join(src, entry.name)
+    const destPath = join(dest, entry.name)
+
+    entry.isDirectory() ?
+      await copyDir(srcPath, destPath) :
+      await fs.copyFile(srcPath, destPath)
+  }
+}
+
+
+type FsSession = ConnectorSession
+
+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'
+
+interface FsOptions {
+  path: string
+  assetsFolder: string
+}
+
+export class FsStorage implements StorageConnector<FsSession> {
+  connectorId = 'fs-storage'
+  displayName = 'File system storage'
+  icon = FILE_ICON
+  disableLogout = true
+  options: FsOptions
+  connectorType = ConnectorType.STORAGE
+  color = '#ffffff'
+  background = '#006400'
+
+  constructor(config: ServerConfig | null, opts: Partial<FsOptions>) {
+    this.options = {
+      path: join(__dirname, '..', '..', '..', '..', 'data'),
+      assetsFolder: '/assets',
+      ...opts,
+    }
+    this.initFs()
+  }
+
+  protected async initFs() {
+    const stat = await fs.stat(this.options.path).catch(() => null)
+    if (!stat) {
+      // create data folder with a default website
+      const id = DEFAULT_WEBSITE_ID
+      await fs.mkdir(join(this.options.path, id, this.options.assetsFolder), { recursive: true })
+      await this.setWebsiteMeta({}, id, { name: 'Default website', connectorUserSettings: {} })
+      await this.updateWebsite({}, id, defaultWebsiteData)
+      console.info(`> [FsStorage] Created ${id} in ${this.options.path}`)
+    }
+  }
+
+  // ********************
+  // Job utils methods
+  // ********************
+  private 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,
+    })
+  }
+
+  private initStatus(files) {
+    return files.map(file => ({
+      file,
+      message: 'Waiting',
+      status: JobStatus.IN_PROGRESS,
+    }))
+  }
+
+  // ********************
+  // Connector interface
+  // ********************
+  getOptions(formData: object): ConnectorOptions {
+    return {}
+  }
+
+  async getOAuthUrl(session: FsSession): Promise<null> { return null }
+
+  async getLoginForm(session: FsSession, redirectTo: string): Promise<string | null> {
+    return null
+  }
+  async getSettingsForm(session: FsSession, redirectTo: string): Promise<string | null> {
+    return null
+  }
+
+  async isLoggedIn(session: FsSession): Promise<boolean> {
+    return true
+  }
+
+  async setToken(session: FsSession, query: object): Promise<void> {}
+
+  async logout(session: FsSession): Promise<void> {}
+
+  async getUser(session: FsSession): Promise<ConnectorUser> {
+    const { username,  } = userInfo()
+    return {
+      name: username,
+      picture: USER_ICON,
+      storage: await toConnectorData(session, this),
+    }
+  }
+
+  async setWebsiteMeta(session: any, id: string, data: WebsiteMetaFileContent): Promise<void> {
+    const websiteId = requiredParam<WebsiteId>(id, 'website id')
+    const content = JSON.stringify(data)
+    const path = join(this.options.path, id, WEBSITE_META_DATA_FILE)
+    await fs.writeFile(path, content)
+  }
+
+  async getWebsiteMeta(session: FsSession, id: WebsiteId): Promise<WebsiteMeta> {
+    const websiteId = requiredParam<WebsiteId>(id, 'website id')
+    // Get stats for website folder
+    const fileStat = await fs.stat(join(this.options.path, websiteId))
+    const path = join(this.options.path, websiteId, WEBSITE_META_DATA_FILE)
+    // Get meta file
+    const content = await fs.readFile(path)
+    const meta = await JSON.parse(content.toString())
+    // Return all meta
+    return {
+      websiteId,
+      name: meta.name,
+      imageUrl: meta.imageUrl,
+      connectorUserSettings: meta.connectorUserSettings,
+      createdAt: fileStat.birthtime,
+      updatedAt: fileStat.mtime,
+    }
+  }
+
+  // ********************
+  // Storage interface
+  // ********************
+  async createWebsite(session: FsSession, meta: WebsiteMetaFileContent): Promise<WebsiteId> {
+    const id = uuid()
+    await fs.mkdir(join(this.options.path, id, this.options.assetsFolder), { recursive: true })
+    await this.setWebsiteMeta(session, id, meta)
+    await this.updateWebsite(session, id, defaultWebsiteData)
+    return id
+  }
+
+  async readWebsite(session: FsSession, websiteId: WebsiteId): Promise<WebsiteData> {
+    const id = requiredParam<WebsiteId>(websiteId, 'website id')
+    const path = join(this.options.path, id, WEBSITE_DATA_FILE)
+    const content = await fs.readFile(path)
+    return JSON.parse(content.toString())
+  }
+
+  async updateWebsite(session: FsSession, websiteId: WebsiteId, data: WebsiteData): Promise<void> {
+    const id = requiredParam<WebsiteId>(websiteId, 'website id')
+    const path = join(this.options.path, id, WEBSITE_DATA_FILE)
+    await fs.writeFile(path, JSON.stringify(data))
+  }
+
+  async deleteWebsite(session: FsSession, websiteId: WebsiteId): Promise<void> {
+    const id = requiredParam<WebsiteId>(websiteId, 'website id')
+    const path = join(this.options.path, id)
+    return fs.rmdir(path, { recursive: true })
+  }
+
+  async duplicateWebsite(session: FsSession, websiteId: WebsiteId): Promise<void> {
+    const newWebsiteId = uuid()
+    const from = join(this.options.path, websiteId)
+    const to = 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: any): Promise<WebsiteMeta[]> {
+    const list = await fs.readdir(this.options.path)
+    return Promise.all(list.map(async fileName => {
+      const websiteId = fileName as WebsiteId
+      return this.getWebsiteMeta(session, websiteId)
+    }))
+  }
+
+  async getAsset(session: FsSession, id: WebsiteId, path: string): Promise<ConnectorFile> {
+    const fullPath = join(this.options.path, id, this.options.assetsFolder, path)
+    const content = await fs.readFile(fullPath)
+    return { path, content }
+  }
+
+  async writeAssets(session: FsSession, id: WebsiteId, files: ConnectorFile[], statusCbk?: StatusCallback): Promise<void> {
+    return this.write(session, id, files, this.options.assetsFolder, statusCbk)
+  }
+
+  async write(session: FsSession, id: WebsiteId, files: ConnectorFile[], assetsFolder: string, statusCbk?: StatusCallback): Promise<void> {
+    const filesStatuses = this.initStatus(files)
+    let error: Error | null = null
+    for (const fileStatus of filesStatuses) {
+      const {file} = fileStatus
+      const path = join(this.options.path, id, assetsFolder, file.path)
+      if (typeof file.content === 'string' || Buffer.isBuffer(file.content)) {
+        fileStatus.message = 'Writing'
+        this.updateStatus(filesStatuses, JobStatus.IN_PROGRESS, statusCbk)
+        try {
+          await fs.writeFile(path, file.content)
+        } catch(err) {
+          fileStatus.message = `Error (${err})`
+          this.updateStatus(filesStatuses, JobStatus.IN_PROGRESS, statusCbk)
+          error = err
+          continue
+        }
+        fileStatus.message = 'Success'
+        this.updateStatus(filesStatuses, JobStatus.IN_PROGRESS, statusCbk)
+      } else if (file.content instanceof Readable) {
+        fileStatus.message = 'Writing'
+        this.updateStatus(filesStatuses, JobStatus.IN_PROGRESS, statusCbk)
+        const writeStream = createWriteStream(path)
+        file.content.pipe(writeStream)
+        await new Promise((resolve) => {
+          writeStream.on('finish', () => {
+            fileStatus.message = 'Success'
+            this.updateStatus(filesStatuses, JobStatus.IN_PROGRESS, statusCbk)
+            resolve(file)
+          })
+          writeStream.on('error', err => {
+            console.error('writeStream error', err)
+            fileStatus.message = `Error (${err})`
+            this.updateStatus(filesStatuses, 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 ? JobStatus.ERROR : JobStatus.SUCCESS, statusCbk)
+    if(error) throw error
+  }
+
+  async deleteAssets(session: FsSession, id: WebsiteId, paths: string[]): Promise<void> {
+    for (const path of paths) {
+      await fs.unlink(join(this.options.path, id, path))
+    }
+  }
+
+  async readAsset(session: object, websiteId: string, fileName: string): Promise<ConnectorFileContent> {
+    const id = requiredParam<WebsiteId>(websiteId, 'website id')
+    const path = join(this.options.path, id, this.options.assetsFolder, fileName)
+    return await fs.readFile(path)
+  }
+}