@silexlabs/silex 3.0.0-alpha.100

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

@@ -0,0 +1,60 @@
+/*
+ * 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 { 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
+
+interface FsOptions {
+  path?: string
+}
+
+export class FsHosting extends FsStorage implements HostingConnector<FsSession> {
+  connectorId = 'fs-hosting'
+  displayName = 'File system hosting'
+  connectorType = ConnectorType.HOSTING
+
+  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)
+    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,261 @@
+/*
+ * 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, { stat } 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)
+}
+
+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 = 'data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20viewBox%3D%220%200%2024%2024%22%20fill%3D%22none%22%20stroke%3D%22currentColor%22%20stroke-width%3D%222%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%3E%3Cpath%20d%3D%22M6%202L6%2022%2018%2022%2018%207%2012%202%206%202Z%22%3E%3C%2Fpath%3E%3Cpath%20d%3D%22M18%202L12%202%2012%208%2018%208%2018%202Z%22%3E%3C%2Fpath%3E%3C%2Fsvg%3E'
+
+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()
+  }
+
+  private 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)
+    }
+  }
+
+  // ********************
+  // 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 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 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, 'binary')
+        } 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)
+  }
+}

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

@@ -0,0 +1,203 @@
+/*
+ * 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 { Readable } from 'stream'
+import { ServerConfig } from '../config'
+import { JobStatus, JobData, ConnectorData, ConnectorId, WebsiteId, ConnectorType, ConnectorUser, WebsiteMeta, WebsiteMetaFileContent, WebsiteData, ConnectorOptions } from '../../types'
+import { JobManager } from '../jobs'
+
+/**
+ * @fileoverview define types for Silex connectors
+ * Bakends can provide storage for website data and assets, and/or hosting to publish the website online
+ */
+
+/**
+ * Connector data stored in the website meta file
+ */
+export type ConnectorFileContent = string | Buffer | Readable
+
+/**
+ * Files are stored in connector as a File object
+ * @see types/ClientSideFile
+ * @see contentToString()
+ */
+export interface ConnectorFile {
+  path: string,
+  content: ConnectorFileContent,
+}
+
+/**
+ * Callback to update the publication status
+ */
+export type StatusCallback = ({message, status}: {message: string, status: JobStatus}) => Promise<void>
+
+export type ConnectorSession = object
+/**
+ * Connectors are the base interface for Storage and Hosting connectors
+ */
+export interface Connector<Session extends ConnectorSession = ConnectorSession> {
+  connectorId: ConnectorId
+  connectorType: ConnectorType
+  displayName: string
+  icon: string
+  disableLogout?: boolean
+  color: string
+  background: string
+  // Get the URL to start the authentication process with OAuth (not used for basic auth)
+  getOAuthUrl(session: Session): Promise<string | null>
+  // Get the form to display to the user to authenticate (not used for OAuth)
+  getLoginForm(session: Session, redirectTo: string): Promise<string | null>
+  // Get the form to display to the user to set the connector settings for a given website
+  getSettingsForm(session: Session, redirectTo: string): Promise<string | null>
+  // Auth and user management
+  isLoggedIn(session: Session): Promise<boolean>
+  setToken(session: Session, token: object): Promise<void>
+  logout(session: Session): Promise<void>
+  getUser(session: Session): Promise<ConnectorUser | null>
+  // Get the connector options from login form
+  // They are stored in the website meta file for hosting connectors
+  // And in the user session for storage connectors
+  getOptions(formData: object): ConnectorOptions
+}
+
+/**
+ * Storage are used to store the website data and assets
+ * And possibly rename files and directories, and get the URL of a file
+ *
+ */
+export interface StorageConnector<Session extends ConnectorSession = ConnectorSession> extends Connector<Session> {
+  // CRUD on websites
+  listWebsites(session: Session): Promise<WebsiteMeta[]>
+  readWebsite(session: Session, websiteId: WebsiteId): Promise<WebsiteData | Readable>
+  createWebsite(session: Session, data: WebsiteMetaFileContent): Promise<WebsiteId>
+  updateWebsite(session: Session, websiteId: WebsiteId, data: WebsiteData): Promise<void>
+  deleteWebsite(session: Session, websiteId: WebsiteId): Promise<void>
+  // CRUD on assets
+  writeAssets(session: Session, websiteId: WebsiteId, files: ConnectorFile[], status?: StatusCallback): Promise<string[] | void>
+  readAsset(session: Session, websiteId: WebsiteId, fileName: string): Promise<ConnectorFileContent>
+  deleteAssets(session: Session, websiteId: WebsiteId, fileNames: string[]): Promise<void>
+  //getFileUrl(session: Session, websiteId: WebsiteId, path: string): Promise<string>
+  // Handle website meta file
+  getWebsiteMeta(session: Session, websiteId: WebsiteId): Promise<WebsiteMeta>
+  setWebsiteMeta(session: Session, websiteId: WebsiteId, data: WebsiteMetaFileContent): Promise<void>
+}
+
+/**
+ * Hosting connectors are used to publish the website
+ */
+export interface HostingConnector<Session extends ConnectorSession = ConnectorSession> extends Connector<Session> {
+  publish(session: Session, websiteId: WebsiteId, files: ConnectorFile[], jobManager: JobManager): Promise<JobData> // Pass the jobManager as plugins do not neccessarily share the same module instance
+  getUrl(session: Session, websiteId: WebsiteId): Promise<string>
+
+}
+
+export function toConnectorEnum(type: string | ConnectorType): ConnectorType {
+  const result = ConnectorType[type.toString().toUpperCase() as keyof typeof ConnectorType]
+  if(!result) throw new Error(`Unknown connector type ${type}. It should be one of ${Object.keys(ConnectorType).join(', ')}`)
+  return result
+}
+
+/**
+ * Get a connector by id or by type
+ */
+export async function getConnector<T extends Connector>(config: ServerConfig, session: any, type: ConnectorType, connectorId?: ConnectorId): Promise<T | undefined> {
+  // Get the connectors for this type
+  const connectors = config.getConnectors(type) as T[]
+
+  // Find the connector by id
+  if (connectorId) return connectors.find(s => s.connectorId === connectorId && s.connectorType === type)
+  // Find the first logged in connector
+  for (const connector of connectors) {
+    if (await connector.isLoggedIn(session)) {
+      return connector
+    }
+  }
+  // Defaults to the first connector
+  return connectors[0]
+}
+
+/**
+ * Convert a connector to a ConnectorData object to be sent to the frontend
+ */
+export async function toConnectorData(session: any, connector: Connector): Promise<ConnectorData> {
+  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,
+  }
+}
+
+export async function contentToString(content: ConnectorFileContent): Promise<string> {
+  // String
+  if (typeof content === 'string') return content
+  // Buffer
+  if (Buffer.isBuffer(content)) return content.toString('utf8')
+  // Stream
+  return new Promise((resolve, reject) => {
+    let result = ''
+    content.on('data', (chunk: Buffer) => {
+      result += chunk.toString('utf8')
+    })
+    content.on('error', (err: Error) => {
+      reject(err)
+    })
+    content.on('end', () => {
+      resolve(result)
+    })
+  })
+}
+
+export async function contentToBuffer(content: ConnectorFileContent): Promise<Buffer> {
+  // String
+  if (typeof content === 'string') return Buffer.from(content, 'utf8')
+  // Buffer
+  if (Buffer.isBuffer(content)) return content
+  // Stream
+  if(content instanceof Readable) {
+    return new Promise((resolve, reject) => {
+      const chunks: Buffer[] = []
+      content.on('data', (chunk: Buffer) => {
+        chunks.push(chunk)
+      })
+      content.on('error', (err: Error) => {
+        reject(err)
+      })
+      content.on('end', () => {
+        resolve(Buffer.concat(chunks))
+      })
+    })
+  }
+  // Unknown
+  throw new Error('Unknown content type')
+}
+
+export function contentToReadable(content: ConnectorFileContent): Readable {
+  // String
+  if (typeof content === 'string') return Readable.from([content])
+  // Buffer
+  if (Buffer.isBuffer(content)) return Readable.from([content])
+  // Stream
+  if (content instanceof Readable) return content
+  // Unknown
+  throw new Error('Unknown content type')
+}

package/src/ts/server/events.ts

@@ -0,0 +1,37 @@
+/*
+ * 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 { ConnectorId, PublicationData, WebsiteData, WebsiteId } from '../types'
+import { ConnectorFile } from './connectors/connectors'
+
+export enum ServerEvent {
+  STARTUP_START = 'startup-start',
+  STARTUP_END = 'startup-end',
+  PUBLISH_START = 'publish-start',
+  PUBLISH_END = 'publish-end',
+  WEBSITE_STORE_START = 'store-start',
+  WEBSITE_STORE_END = 'store-end',
+  WEBSITE_ASSET_STORE_START = 'asset-store-start',
+  WEBSITE_ASSET_STORE_END = 'asset-store-end',
+}
+
+export type PublishStartEventType = PublicationData
+export type PublishEndEventType = Error | null
+export type WebsiteStoreStartEventType = { websiteId: WebsiteId, websiteData: WebsiteData, connectorId: ConnectorId}
+export type WebsiteStoreEndEventType = Error | null
+export type WebsiteAssetStoreStartEventType = { files: ConnectorFile[], websiteId: WebsiteId, connectorId: ConnectorId}
+export type WebsiteAssetStoreEndEventType = Error | null

package/src/ts/server/expose.ts

@@ -0,0 +1,19 @@
+/*
+ * 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/>.
+ */
+
+
+export * as events from './events'