initial production release 🎉

2021-03-24 22:11:14 +01:00
commit dbe82b3e7c
101 changed files with 12479 additions and 0 deletions
--- a/api/app.js
+++ b/api/app.js
@@ -0,0 +1,27 @@
+module.exports = async function (fastify, opts) {
+  // Private routes
+  fastify.register(async function (server) {
+    if (process.env.NODE_ENV === 'production') server.register(require('./plugins/authentication'))
+    server.register(require('./routes/v1/upgrade'), { prefix: '/upgrade' })
+    server.register(require('./routes/v1/settings'), { prefix: '/settings' })
+    server.register(require('./routes/v1/dashboard'), { prefix: '/dashboard' })
+    server.register(require('./routes/v1/config'), { prefix: '/config' })
+    server.register(require('./routes/v1/application/remove'), { prefix: '/application/remove' })
+    server.register(require('./routes/v1/application/logs'), { prefix: '/application/logs' })
+    server.register(require('./routes/v1/application/check'), { prefix: '/application/check' })
+    server.register(require('./routes/v1/application/deploy'), { prefix: '/application/deploy' })
+    server.register(require('./routes/v1/application/deploy/logs'), { prefix: '/application/deploy/logs' })
+    server.register(require('./routes/v1/databases'), { prefix: '/databases' })
+  })
+  // Public routes
+  fastify.register(require('./routes/v1/verify'), { prefix: '/verify' })
+  fastify.register(require('./routes/v1/login/github'), {
+    prefix: '/login/github'
+  })
+  fastify.register(require('./routes/v1/webhooks/deploy'), {
+    prefix: '/webhooks/deploy'
+  })
+  fastify.register(require('./routes/v1/undead'), {
+    prefix: '/undead'
+  })
+}
--- a/api/development/mongodb.js
+++ b/api/development/mongodb.js
@@ -0,0 +1,36 @@
+const mongoose = require('mongoose')
+const { MongoMemoryServer } = require('mongodb-memory-server-core')
+
+const mongoServer = new MongoMemoryServer({
+  instance: {
+    port: 27017,
+    dbName: 'coolify',
+    storageEngine: 'wiredTiger'
+  },
+  binary: {
+    version: '4.4.3'
+
+  }
+})
+
+mongoose.Promise = Promise
+mongoServer.getUri().then((mongoUri) => {
+  const mongooseOpts = {
+    useNewUrlParser: true,
+    useUnifiedTopology: true
+  }
+
+  mongoose.connect(mongoUri, mongooseOpts)
+
+  mongoose.connection.on('error', (e) => {
+    if (e.message.code === 'ETIMEDOUT') {
+      console.log(e)
+      mongoose.connect(mongoUri, mongooseOpts)
+    }
+    console.log(e)
+  })
+
+  mongoose.connection.once('open', () => {
+    console.log(`Started in-memory mongodb ${mongoUri}`)
+  })
+})
--- a/api/libs/applications/build/container.js
+++ b/api/libs/applications/build/container.js
@@ -0,0 +1,34 @@
+const packs = require('../../../packs')
+const { saveAppLog } = require('../../logging')
+const Deployment = require('../../../models/Deployment')
+
+module.exports = async function (configuration) {
+  const { id, organization, name, branch } = configuration.repository
+  const { domain } = configuration.publish
+  const deployId = configuration.general.deployId
+
+  const execute = packs[configuration.build.pack]
+  if (execute) {
+    try {
+      await Deployment.findOneAndUpdate(
+        { repoId: id, branch, deployId, organization, name, domain },
+        { repoId: id, branch, deployId, organization, name, domain, progress: 'inprogress' })
+      await saveAppLog('### Building application.', configuration)
+
+      await execute(configuration)
+
+      await saveAppLog('### Building done.', configuration)
+    } catch (error) {
+      await Deployment.findOneAndUpdate(
+        { repoId: id, branch, deployId, organization, name, domain },
+        { repoId: id, branch, deployId, organization, name, domain, progress: 'failed' })
+      if (error.stack) throw { error: error.stack, type: 'server' }
+      throw { error, type: 'app' }
+    }
+  } else {
+    await Deployment.findOneAndUpdate(
+      { repoId: id, branch, deployId, organization, name, domain },
+      { repoId: id, branch, deployId, organization, name, domain, progress: 'failed' })
+    throw { error: 'No buildpack found.', type: 'app' }
+  }
+}
--- a/api/libs/applications/cleanup/index.js
+++ b/api/libs/applications/cleanup/index.js
@@ -0,0 +1,41 @@
+const { docker } = require('../../docker')
+const { execShellAsync, delay } = require('../../common')
+const Deployment = require('../../../models/Deployment')
+
+async function purgeOldThings () {
+  try {
+    await docker.engine.pruneImages()
+    await docker.engine.pruneContainers()
+  } catch (error) {
+    throw { error, type: 'server' }
+  }
+}
+
+async function cleanup (configuration) {
+  const { id } = configuration.repository
+  const deployId = configuration.general.deployId
+  try {
+    // Cleanup stucked deployments.
+    const deployments = await Deployment.find({ repoId: id, deployId: { $ne: deployId }, progress: { $in: ['queued', 'inprogress'] } })
+    for (const deployment of deployments) {
+      await Deployment.findByIdAndUpdate(deployment._id, { $set: { progress: 'failed' } })
+    }
+  } catch (error) {
+    throw { error, type: 'server' }
+  }
+}
+
+async function deleteSameDeployments (configuration) {
+  try {
+    await (await docker.engine.listServices()).filter(r => r.Spec.Labels.managedBy === 'coolify' && r.Spec.Labels.type === 'application').map(async s => {
+      const running = JSON.parse(s.Spec.Labels.configuration)
+      if (running.repository.id === configuration.repository.id && running.repository.branch === configuration.repository.branch) {
+        await execShellAsync(`docker stack rm ${s.Spec.Labels['com.docker.stack.namespace']}`)
+      }
+    })
+  } catch (error) {
+    throw { error, type: 'server' }
+  }
+}
+
+module.exports = { cleanup, deleteSameDeployments, purgeOldThings }
--- a/api/libs/applications/configuration.js
+++ b/api/libs/applications/configuration.js
@@ -0,0 +1,62 @@
+const { uniqueNamesGenerator, adjectives, colors, animals } = require('unique-names-generator')
+const cuid = require('cuid')
+const { execShellAsync } = require('../common')
+const crypto = require('crypto')
+
+function getUniq () {
+  return uniqueNamesGenerator({ dictionaries: [adjectives, animals, colors], length: 2 })
+}
+
+function setDefaultConfiguration (configuration) {
+  try {
+    const nickname = getUniq()
+    const deployId = cuid()
+
+    const shaBase = JSON.stringify({ repository: configuration.repository })
+    const sha256 = crypto.createHash('sha256').update(shaBase).digest('hex')
+
+    configuration.build.container.name = sha256.slice(0, 15)
+
+    configuration.general.nickname = nickname
+    configuration.general.deployId = deployId
+    configuration.general.workdir = `/tmp/${deployId}`
+
+    if (!configuration.publish.path) configuration.publish.path = '/'
+    if (!configuration.publish.port) configuration.publish.port = configuration.build.pack === 'static' ? 80 : 3000
+
+    if (configuration.build.pack === 'static') {
+      if (!configuration.build.command.installation) configuration.build.command.installation = 'yarn install'
+      if (!configuration.build.directory) configuration.build.directory = '/'
+    }
+
+    if (configuration.build.pack === 'nodejs') {
+      if (!configuration.build.command.installation) configuration.build.command.installation = 'yarn install'
+      if (!configuration.build.directory) configuration.build.directory = '/'
+    }
+
+    return configuration
+  } catch (error) {
+    throw { error, type: 'server' }
+  }
+}
+
+async function updateServiceLabels (configuration, services) {
+  // In case of any failure during deployment, still update the current configuration.
+  const found = services.find(s => {
+    const config = JSON.parse(s.Spec.Labels.configuration)
+    if (config.repository.id === configuration.repository.id && config.repository.branch === configuration.repository.branch) {
+      return config
+    }
+    return null
+  })
+  if (found) {
+    const { ID } = found
+    try {
+      const Labels = { ...JSON.parse(found.Spec.Labels.configuration), ...configuration }
+      execShellAsync(`docker service update --label-add configuration='${JSON.stringify(Labels)}' --label-add com.docker.stack.image='${configuration.build.container.name}:${configuration.build.container.tag}' ${ID}`)
+    } catch (error) {
+      console.log(error)
+    }
+  }
+}
+module.exports = { setDefaultConfiguration, updateServiceLabels }
--- a/api/libs/applications/deploy/copyFiles.js
+++ b/api/libs/applications/deploy/copyFiles.js
@@ -0,0 +1,53 @@
+const fs = require('fs').promises
+module.exports = async function (configuration) {
+  try {
+    // TODO: Do it better.
+    await fs.writeFile(`${configuration.general.workdir}/.dockerignore`, 'node_modules')
+    await fs.writeFile(
+      `${configuration.general.workdir}/nginx.conf`,
+      `user  nginx;
+        worker_processes  auto;
+        
+        error_log  /var/log/nginx/error.log warn;
+        pid        /var/run/nginx.pid;
+        
+        events {
+            worker_connections  1024;
+        }
+        
+        http {
+            include       /etc/nginx/mime.types;
+        
+            access_log      off;
+            sendfile        on;
+            #tcp_nopush     on;
+            keepalive_timeout  65;
+
+            server {
+                listen       80;
+                server_name  localhost;
+                
+                location / {
+                    root   /usr/share/nginx/html;
+                    index  index.html;
+                    try_files $uri $uri/index.html $uri/ /index.html =404;
+                }
+        
+                error_page  404              /50x.html;
+        
+                # redirect server error pages to the static page /50x.html
+                #
+                error_page   500 502 503 504  /50x.html;
+                location = /50x.html {
+                    root   /usr/share/nginx/html;
+                }  
+        
+            }
+        
+        }
+        `
+    )
+  } catch (error) {
+    throw { error, type: 'server' }
+  }
+}
--- a/api/libs/applications/deploy/deploy.js
+++ b/api/libs/applications/deploy/deploy.js
@@ -0,0 +1,97 @@
+const yaml = require('js-yaml')
+const { execShellAsync } = require('../../common')
+const { docker } = require('../../docker')
+const { saveAppLog } = require('../../logging')
+const { deleteSameDeployments } = require('../cleanup')
+const fs = require('fs').promises
+
+module.exports = async function (configuration, configChanged, imageChanged) {
+  try {
+    const generateEnvs = {}
+    for (const secret of configuration.publish.secrets) {
+      generateEnvs[secret.name] = secret.value
+    }
+    const containerName = configuration.build.container.name
+    const stack = {
+      version: '3.8',
+      services: {
+        [containerName]: {
+          image: `${configuration.build.container.name}:${configuration.build.container.tag}`,
+          networks: [`${docker.network}`],
+          environment: generateEnvs,
+          deploy: {
+            replicas: 1,
+            restart_policy: {
+              condition: 'on-failure',
+              delay: '5s',
+              max_attempts: 1,
+              window: '120s'
+            },
+            update_config: {
+              parallelism: 1,
+              delay: '10s',
+              order: 'start-first'
+            },
+            rollback_config: {
+              parallelism: 1,
+              delay: '10s',
+              order: 'start-first'
+            },
+            labels: [
+              'managedBy=coolify',
+              'type=application',
+              'configuration=' + JSON.stringify(configuration),
+              'traefik.enable=true',
+              'traefik.http.services.' +
+              configuration.build.container.name +
+              `.loadbalancer.server.port=${configuration.publish.port}`,
+              'traefik.http.routers.' +
+              configuration.build.container.name +
+              '.entrypoints=websecure',
+              'traefik.http.routers.' +
+              configuration.build.container.name +
+              '.rule=Host(`' +
+              configuration.publish.domain +
+              '`) && PathPrefix(`' +
+              configuration.publish.path +
+              '`)',
+              'traefik.http.routers.' +
+              configuration.build.container.name +
+              '.tls.certresolver=letsencrypt',
+              'traefik.http.routers.' +
+              configuration.build.container.name +
+              '.middlewares=global-compress'
+            ]
+          }
+        }
+      },
+      networks: {
+        [`${docker.network}`]: {
+          external: true
+        }
+      }
+    }
+    await saveAppLog('### Publishing.', configuration)
+    await fs.writeFile(`${configuration.general.workdir}/stack.yml`, yaml.dump(stack))
+    if (configChanged) {
+      // console.log('configuration changed')
+      await execShellAsync(
+        `cat ${configuration.general.workdir}/stack.yml | docker stack deploy --prune -c - ${containerName}`
+      )
+    } else if (imageChanged) {
+      // console.log('image changed')
+      await execShellAsync(`docker service update --image ${configuration.build.container.name}:${configuration.build.container.tag} ${configuration.build.container.name}_${configuration.build.container.name}`)
+    } else {
+      // console.log('new deployment or force deployment')
+      await deleteSameDeployments(configuration)
+      await execShellAsync(
+        `cat ${configuration.general.workdir}/stack.yml | docker stack deploy --prune -c - ${containerName}`
+      )
+    }
+
+    await saveAppLog('### Published done!', configuration)
+  } catch (error) {
+    await saveAppLog(`Error occured during deployment: ${error.message}`, configuration)
+    throw { error, type: 'server' }
+  }
+}
--- a/api/libs/applications/github/cloneRepository.js
+++ b/api/libs/applications/github/cloneRepository.js
@@ -0,0 +1,44 @@
+const jwt = require('jsonwebtoken')
+const axios = require('axios')
+const { execShellAsync, cleanupTmp } = require('../../common')
+
+module.exports = async function (configuration) {
+  const { workdir } = configuration.general
+  const { organization, name, branch } = configuration.repository
+  const github = configuration.github
+
+  const githubPrivateKey = process.env.GITHUB_APP_PRIVATE_KEY.replace(/\\n/g, '\n').replace(/"/g, '')
+
+  const payload = {
+    iat: Math.round(new Date().getTime() / 1000),
+    exp: Math.round(new Date().getTime() / 1000 + 60),
+    iss: parseInt(github.app.id)
+  }
+
+  try {
+    const jwtToken = jwt.sign(payload, githubPrivateKey, {
+      algorithm: 'RS256'
+    })
+    const accessToken = await axios({
+      method: 'POST',
+      url: `https://api.github.com/app/installations/${github.installation.id}/access_tokens`,
+      data: {},
+      headers: {
+        Authorization: 'Bearer ' + jwtToken,
+        Accept: 'application/vnd.github.machine-man-preview+json'
+      }
+    })
+    await execShellAsync(
+      `mkdir -p ${workdir} && git clone -q -b ${branch} https://x-access-token:${accessToken.data.token}@github.com/${organization}/${name}.git ${workdir}/`
+    )
+    configuration.build.container.tag = (
+      await execShellAsync(`cd ${configuration.general.workdir}/ && git rev-parse HEAD`)
+    )
+      .replace('\n', '')
+      .slice(0, 7)
+  } catch (error) {
+    cleanupTmp(workdir)
+    if (error.stack) console.log(error.stack)
+    throw { error, type: 'server' }
+  }
+}
--- a/api/libs/applications/index.js
+++ b/api/libs/applications/index.js
@@ -0,0 +1,44 @@
+const dayjs = require('dayjs')
+
+const { saveServerLog } = require('../logging')
+const { cleanupTmp } = require('../common')
+
+const { saveAppLog } = require('../logging')
+const copyFiles = require('./deploy/copyFiles')
+const buildContainer = require('./build/container')
+const deploy = require('./deploy/deploy')
+const Deployment = require('../../models/Deployment')
+const { cleanup, purgeOldThings } = require('./cleanup')
+const { updateServiceLabels } = require('./configuration')
+
+async function queueAndBuild (configuration, services, configChanged, imageChanged) {
+  const { id, organization, name, branch } = configuration.repository
+  const { domain } = configuration.publish
+  const { deployId, nickname, workdir } = configuration.general
+  try {
+    await new Deployment({
+      repoId: id, branch, deployId, domain, organization, name, nickname
+    }).save()
+    await saveAppLog(`${dayjs().format('YYYY-MM-DD HH:mm:ss.SSS')} Queued.`, configuration)
+    await copyFiles(configuration)
+    await buildContainer(configuration)
+    await deploy(configuration, configChanged, imageChanged)
+    await Deployment.findOneAndUpdate(
+      { repoId: id, branch, deployId, organization, name, domain },
+      { repoId: id, branch, deployId, organization, name, domain, progress: 'done' })
+    await updateServiceLabels(configuration, services)
+    cleanupTmp(workdir)
+    await purgeOldThings()
+  } catch (error) {
+    await cleanup(configuration)
+    cleanupTmp(workdir)
+    const { type } = error.error
+    if (type === 'app') {
+      await saveAppLog(error.error, configuration, true)
+    } else {
+      await saveServerLog({ event: error.error, configuration })
+    }
+  }
+}
+
+module.exports = { queueAndBuild }
--- a/api/libs/common.js
+++ b/api/libs/common.js
@@ -0,0 +1,94 @@
+const crypto = require('crypto')
+const shell = require('shelljs')
+const jsonwebtoken = require('jsonwebtoken')
+const { docker } = require('./docker')
+const User = require('../models/User')
+const algorithm = 'aes-256-cbc'
+const key = process.env.SECRETS_ENCRYPTION_KEY
+
+function delay (t) {
+  return new Promise(function (resolve) {
+    setTimeout(function () {
+      resolve('OK')
+    }, t)
+  })
+}
+
+async function verifyUserId (authorization) {
+  const token = authorization.split(' ')[1]
+  const verify = jsonwebtoken.verify(token, process.env.JWT_SIGN_KEY)
+  const found = await User.findOne({ uid: verify.jti })
+  if (found) {
+    return true
+  } else {
+    return false
+  }
+}
+function execShellAsync (cmd, opts = {}) {
+  try {
+    return new Promise(function (resolve, reject) {
+      shell.config.silent = true
+      shell.exec(cmd, opts, function (code, stdout, stderr) {
+        if (code !== 0) return reject(new Error(stderr))
+        return resolve(stdout)
+      })
+    })
+  } catch (error) {
+    return new Error('Oops')
+  }
+}
+function cleanupTmp (dir) {
+  if (dir !== '/') shell.rm('-fr', dir)
+}
+
+async function checkImageAvailable (name) {
+  let cacheAvailable = false
+  try {
+    await docker.engine.getImage(name).get()
+    cacheAvailable = true
+  } catch (e) {
+    // Cache image not found
+  }
+  return cacheAvailable
+}
+
+function encryptData (text) {
+  const iv = crypto.randomBytes(16)
+  const cipher = crypto.createCipheriv(algorithm, Buffer.from(key), iv)
+  let encrypted = cipher.update(text)
+  encrypted = Buffer.concat([encrypted, cipher.final()])
+  return { iv: iv.toString('hex'), encryptedData: encrypted.toString('hex') }
+}
+
+function decryptData (text) {
+  const iv = Buffer.from(text.iv, 'hex')
+  const encryptedText = Buffer.from(text.encryptedData, 'hex')
+  const decipher = crypto.createDecipheriv(algorithm, Buffer.from(key), iv)
+  let decrypted = decipher.update(encryptedText)
+  decrypted = Buffer.concat([decrypted, decipher.final()])
+  return decrypted.toString()
+}
+
+function createToken (payload) {
+  const { uuid } = payload
+  return jsonwebtoken.sign({}, process.env.JWT_SIGN_KEY, {
+    expiresIn: 15778800,
+    algorithm: 'HS256',
+    audience: 'coolify',
+    issuer: 'coolify',
+    jwtid: uuid,
+    subject: `User:${uuid}`,
+    notBefore: -1000
+  })
+}
+
+module.exports = {
+  delay,
+  createToken,
+  execShellAsync,
+  cleanupTmp,
+  checkImageAvailable,
+  encryptData,
+  decryptData,
+  verifyUserId
+}
--- a/api/libs/docker.js
+++ b/api/libs/docker.js
@@ -0,0 +1,31 @@
+const Dockerode = require('dockerode')
+const { saveAppLog } = require('./logging')
+
+const docker = {
+  engine: new Dockerode({
+    socketPath: process.env.DOCKER_ENGINE
+  }),
+  network: process.env.DOCKER_NETWORK
+}
+async function streamEvents (stream, configuration) {
+  try {
+    await new Promise((resolve, reject) => {
+      docker.engine.modem.followProgress(stream, onFinished, onProgress)
+      function onFinished (err, res) {
+        if (err) reject(err)
+        resolve(res)
+      }
+      function onProgress (event) {
+        if (event.error) {
+          reject(event.error)
+          return
+        }
+        saveAppLog(event.stream, configuration)
+      }
+    })
+  } catch (error) {
+    throw { error, type: 'app' }
+  }
+}
+
+module.exports = { streamEvents, docker }
--- a/api/libs/logging.js
+++ b/api/libs/logging.js
@@ -0,0 +1,55 @@
+const ApplicationLog = require('../models/Logs/Application')
+const ServerLog = require('../models/Logs/Server')
+const dayjs = require('dayjs')
+
+function generateTimestamp () {
+  return `${dayjs().format('YYYY-MM-DD HH:mm:ss.SSS')} `
+}
+
+async function saveAppLog (event, configuration, isError) {
+  try {
+    const deployId = configuration.general.deployId
+    const repoId = configuration.repository.id
+    const branch = configuration.repository.branch
+    if (isError) {
+      // console.log(event, config, isError)
+      let clearedEvent = null
+
+      if (event.error) clearedEvent = '[ERROR] ' + generateTimestamp() + event.error.replace(/(\r\n|\n|\r)/gm, '')
+      else if (event) clearedEvent = '[ERROR] ' + generateTimestamp() + event.replace(/(\r\n|\n|\r)/gm, '')
+
+      try {
+        await new ApplicationLog({ repoId, branch, deployId, event: clearedEvent }).save()
+      } catch (error) {
+        console.log(error)
+      }
+    } else {
+      if (event && event !== '\n') {
+        const clearedEvent = '[INFO] ' + generateTimestamp() + event.replace(/(\r\n|\n|\r)/gm, '')
+        try {
+          await new ApplicationLog({ repoId, branch, deployId, event: clearedEvent }).save()
+        } catch (error) {
+          console.log(error)
+        }
+      }
+    }
+  } catch (error) {
+    console.log(error)
+    return error
+  }
+}
+
+async function saveServerLog ({ event, configuration, type }) {
+  if (configuration) {
+    const deployId = configuration.general.deployId
+    const repoId = configuration.repository.id
+    const branch = configuration.repository.branch
+    await new ApplicationLog({ repoId, branch, deployId, event: `[SERVER ERROR 😖]: ${event}` }).save()
+  }
+  await new ServerLog({ event, type }).save()
+}
+
+module.exports = {
+  saveAppLog,
+  saveServerLog
+}
--- a/api/models/Deployment.js
+++ b/api/models/Deployment.js
@@ -0,0 +1,16 @@
+const mongoose = require('mongoose')
+const deploymentSchema = mongoose.Schema(
+  {
+    deployId: { type: String, required: true },
+    nickname: { type: String, required: true },
+    repoId: { type: Number, required: true },
+    organization: { type: String, required: true },
+    name: { type: String, required: true },
+    branch: { type: String, required: true },
+    domain: { type: String, required: true },
+    progress: { type: String, require: true, default: 'queued' }
+  },
+  { timestamps: true }
+)
+
+module.exports = mongoose.model('deployment', deploymentSchema)
--- a/api/models/Logs/Application.js
+++ b/api/models/Logs/Application.js
@@ -0,0 +1,10 @@
+const mongoose = require('mongoose')
+const logSchema = mongoose.Schema(
+  {
+    deployId: { type: String, required: true },
+    event: { type: String, required: true }
+  },
+  { timestamps: { createdAt: 'createdAt', updatedAt: false } }
+)
+
+module.exports = mongoose.model('logs-application', logSchema)
--- a/api/models/Logs/Server.js
+++ b/api/models/Logs/Server.js
@@ -0,0 +1,13 @@
+const mongoose = require('mongoose')
+const { version } = require('../../../package.json')
+const logSchema = mongoose.Schema(
+  {
+    version: { type: String, required: true, default: version },
+    type: { type: String, required: true, enum: ['API', 'UPGRADE-P-1', 'UPGRADE-P-2'], default: 'API' },
+    event: { type: String, required: true },
+    seen: { type: Boolean, required: true, default: false }
+  },
+  { timestamps: { createdAt: 'createdAt', updatedAt: false } }
+)
+
+module.exports = mongoose.model('logs-server', logSchema)
--- a/api/models/Settings.js
+++ b/api/models/Settings.js
@@ -0,0 +1,11 @@
+const mongoose = require('mongoose')
+
+const settingsSchema = mongoose.Schema(
+  {
+    applicationName: { type: String, required: true, default: 'coolify' },
+    allowRegistration: { type: Boolean, required: true, default: false }
+  },
+  { timestamps: true }
+)
+
+module.exports = mongoose.model('settings', settingsSchema)
--- a/api/models/User.js
+++ b/api/models/User.js
@@ -0,0 +1,12 @@
+const mongoose = require('mongoose')
+
+const userSchema = mongoose.Schema(
+  {
+    email: { type: String, required: true },
+    avatar: { type: String },
+    uid: { type: String, required: true }
+  },
+  { timestamps: true }
+)
+
+module.exports = mongoose.model('user', userSchema)
--- a/api/packs/helpers.js
+++ b/api/packs/helpers.js
@@ -0,0 +1,28 @@
+const fs = require('fs').promises
+const { streamEvents, docker } = require('../libs/docker')
+
+async function buildImage (configuration) {
+  let dockerFile = `
+                # build
+                FROM node:lts
+                WORKDIR /usr/src/app
+                COPY package*.json .
+                `
+  if (configuration.build.command.installation) {
+    dockerFile += `RUN ${configuration.build.command.installation}
+                `
+  }
+  dockerFile += `COPY . .
+            RUN ${configuration.build.command.build}`
+
+  await fs.writeFile(`${configuration.general.workdir}/Dockerfile`, dockerFile)
+  const stream = await docker.engine.buildImage(
+    { src: ['.'], context: configuration.general.workdir },
+    { t: `${configuration.build.container.name}:${configuration.build.container.tag}` }
+  )
+  await streamEvents(stream, configuration)
+}
+
+module.exports = {
+  buildImage
+}
--- a/api/packs/index.js
+++ b/api/packs/index.js
@@ -0,0 +1,4 @@
+const static = require('./static')
+const nodejs = require('./nodejs')
+
+module.exports = { static, nodejs }
--- a/api/packs/nodejs/index.js
+++ b/api/packs/nodejs/index.js
@@ -0,0 +1,32 @@
+const fs = require('fs').promises
+const { buildImage } = require('../helpers')
+const { streamEvents, docker } = require('../../libs/docker')
+
+module.exports = async function (configuration) {
+  if (configuration.build.command.build) await buildImage(configuration)
+
+  let dockerFile = `# production stage
+      FROM node:lts
+      WORKDIR /usr/src/app
+      `
+  if (configuration.build.command.build) {
+    dockerFile += `COPY --from=${configuration.build.container.name}:${configuration.build.container.tag} /usr/src/app/${configuration.build.directory} /usr/src/app`
+  } else {
+    dockerFile += 'COPY . ./'
+  }
+  if (configuration.build.command.installation) {
+    dockerFile += `
+      RUN ${configuration.build.command.installation}
+      `
+  }
+  dockerFile += `
+        EXPOSE ${configuration.publish.port}
+        CMD [ "yarn", "start" ]`
+
+  await fs.writeFile(`${configuration.general.workdir}/Dockerfile`, dockerFile)
+  const stream = await docker.engine.buildImage(
+    { src: ['.'], context: configuration.general.workdir },
+    { t: `${configuration.build.container.name}:${configuration.build.container.tag}` }
+  )
+  await streamEvents(stream, configuration)
+}
--- a/api/packs/static/index.js
+++ b/api/packs/static/index.js
@@ -0,0 +1,28 @@
+const fs = require('fs').promises
+const { buildImage } = require('../helpers')
+const { streamEvents, docker } = require('../../libs/docker')
+
+module.exports = async function (configuration) {
+  if (configuration.build.command.build) await buildImage(configuration)
+
+  let dockerFile = `# production stage
+    FROM nginx:stable-alpine
+    COPY nginx.conf /etc/nginx/nginx.conf
+    `
+  if (configuration.build.command.build) {
+    dockerFile += `COPY --from=${configuration.build.container.name}:${configuration.build.container.tag} /usr/src/app/${configuration.build.directory} /usr/share/nginx/html`
+  } else {
+    dockerFile += 'COPY . /usr/share/nginx/html'
+  }
+
+  dockerFile += `
+      EXPOSE 80
+      CMD ["nginx", "-g", "daemon off;"]`
+  await fs.writeFile(`${configuration.general.workdir}/Dockerfile`, dockerFile)
+
+  const stream = await docker.engine.buildImage(
+    { src: ['.'], context: configuration.general.workdir },
+    { t: `${configuration.build.container.name}:${configuration.build.container.tag}` }
+  )
+  await streamEvents(stream, configuration)
+}
--- a/api/plugins/authentication.js
+++ b/api/plugins/authentication.js
@@ -0,0 +1,21 @@
+const fp = require('fastify-plugin')
+const User = require('../models/User')
+module.exports = fp(async function (fastify, options, next) {
+  fastify.register(require('fastify-jwt'), {
+    secret: fastify.config.JWT_SIGN_KEY
+  })
+  fastify.addHook('onRequest', async (request, reply) => {
+    try {
+      const { jti } = await request.jwtVerify()
+      const found = await User.findOne({ uid: jti })
+      if (found) {
+        return true
+      } else {
+        reply.code(401).send('Unauthorized')
+      }
+    } catch (err) {
+      reply.code(401).send('Unauthorized')
+    }
+  })
+  next()
+})
--- a/api/routes/v1/application/check.js
+++ b/api/routes/v1/application/check.js
@@ -0,0 +1,35 @@
+
+const { verifyUserId } = require('../../../libs/common')
+const { setDefaultConfiguration } = require('../../../libs/applications/configuration')
+const { docker } = require('../../../libs/docker')
+
+module.exports = async function (fastify) {
+  fastify.post('/', async (request, reply) => {
+    if (!await verifyUserId(request.headers.authorization)) {
+      reply.code(500).send({ error: 'Invalid request' })
+      return
+    }
+    const configuration = setDefaultConfiguration(request.body)
+
+    const services = (await docker.engine.listServices()).filter(r => r.Spec.Labels.managedBy === 'coolify' && r.Spec.Labels.type === 'application')
+    let foundDomain = false
+
+    for (const service of services) {
+      const running = JSON.parse(service.Spec.Labels.configuration)
+      if (running) {
+        if (
+          running.publish.domain === configuration.publish.domain &&
+          running.repository.id !== configuration.repository.id
+        ) {
+          foundDomain = true
+        }
+      }
+    }
+    if (fastify.config.DOMAIN === configuration.publish.domain) foundDomain = true
+    if (foundDomain) {
+      reply.code(500).send({ message: 'Domain already in use.' })
+      return
+    }
+    return { message: 'OK' }
+  })
+}
--- a/api/routes/v1/application/deploy/index.js
+++ b/api/routes/v1/application/deploy/index.js
@@ -0,0 +1,117 @@
+
+const { verifyUserId, cleanupTmp, execShellAsync } = require('../../../../libs/common')
+const Deployment = require('../../../../models/Deployment')
+const { queueAndBuild } = require('../../../../libs/applications')
+const { setDefaultConfiguration } = require('../../../../libs/applications/configuration')
+const { docker } = require('../../../../libs/docker')
+const cloneRepository = require('../../../../libs/applications/github/cloneRepository')
+
+module.exports = async function (fastify) {
+  // const postSchema = {
+  //     body: {
+  //         type: "object",
+  //         properties: {
+  //             ref: { type: "string" },
+  //             repository: {
+  //                 type: "object",
+  //                 properties: {
+  //                     id: { type: "number" },
+  //                     full_name: { type: "string" },
+  //                 },
+  //                 required: ["id", "full_name"],
+  //             },
+  //             installation: {
+  //                 type: "object",
+  //                 properties: {
+  //                     id: { type: "number" },
+  //                 },
+  //                 required: ["id"],
+  //             },
+  //         },
+  //         required: ["ref", "repository", "installation"],
+  //     },
+  // };
+  fastify.post('/', async (request, reply) => {
+    if (!await verifyUserId(request.headers.authorization)) {
+      reply.code(500).send({ error: 'Invalid request' })
+      return
+    }
+
+    const configuration = setDefaultConfiguration(request.body)
+
+    const services = (await docker.engine.listServices()).filter(r => r.Spec.Labels.managedBy === 'coolify' && r.Spec.Labels.type === 'application')
+
+    await cloneRepository(configuration)
+
+    let foundService = false
+    let foundDomain = false
+    let configChanged = false
+    let imageChanged = false
+
+    let forceUpdate = false
+
+    for (const service of services) {
+      const running = JSON.parse(service.Spec.Labels.configuration)
+      if (running) {
+        if (
+          running.publish.domain === configuration.publish.domain &&
+          running.repository.id !== configuration.repository.id
+        ) {
+          foundDomain = true
+        }
+        if (running.repository.id === configuration.repository.id && running.repository.branch === configuration.repository.branch) {
+          const state = await execShellAsync(`docker stack ps ${running.build.container.name} --format '{{ json . }}'`)
+          const isError = state.split('\n').filter(n => n).map(s => JSON.parse(s)).filter(n => n.DesiredState !== 'Running')
+          if (isError.length > 0) forceUpdate = true
+
+          foundService = true
+          const runningWithoutContainer = JSON.parse(JSON.stringify(running))
+          delete runningWithoutContainer.build.container
+
+          const configurationWithoutContainer = JSON.parse(JSON.stringify(configuration))
+          delete configurationWithoutContainer.build.container
+
+          // If only the configuration changed
+          if (JSON.stringify(runningWithoutContainer.build) !== JSON.stringify(configurationWithoutContainer.build) || JSON.stringify(runningWithoutContainer.publish) !== JSON.stringify(configurationWithoutContainer.publish)) configChanged = true
+          // If only the image changed
+          if (running.build.container.tag !== configuration.build.container.tag) imageChanged = true
+          // If build pack changed, forceUpdate the service
+          if (running.build.pack !== configuration.build.pack) forceUpdate = true
+        }
+      }
+    }
+    if (foundDomain) {
+      cleanupTmp(configuration.general.workdir)
+      reply.code(500).send({ message: 'Domain already in use.' })
+      return
+    }
+    if (forceUpdate) {
+      imageChanged = false
+      configChanged = false
+    } else {
+      if (foundService && !imageChanged && !configChanged) {
+        cleanupTmp(configuration.general.workdir)
+        reply.code(500).send({ message: 'Nothing changed, no need to redeploy.' })
+        return
+      }
+    }
+
+    const alreadyQueued = await Deployment.find({
+      repoId: configuration.repository.id,
+      branch: configuration.repository.branch,
+      organization: configuration.repository.organization,
+      name: configuration.repository.name,
+      domain: configuration.publish.domain,
+      progress: { $in: ['queued', 'inprogress'] }
+    })
+
+    if (alreadyQueued.length > 0) {
+      reply.code(200).send({ message: 'Already in the queue.' })
+      return
+    }
+
+    queueAndBuild(configuration, services, configChanged, imageChanged)
+
+    reply.code(201).send({ message: 'Deployment queued.', nickname: configuration.general.nickname, name: configuration.build.container.name })
+  })
+}
--- a/api/routes/v1/application/deploy/logs.js
+++ b/api/routes/v1/application/deploy/logs.js
@@ -0,0 +1,62 @@
+const ApplicationLog = require('../../../../models/Logs/Application')
+const Deployment = require('../../../../models/Deployment')
+const dayjs = require('dayjs')
+const utc = require('dayjs/plugin/utc')
+const relativeTime = require('dayjs/plugin/relativeTime')
+dayjs.extend(utc)
+dayjs.extend(relativeTime)
+
+module.exports = async function (fastify) {
+  const getLogSchema = {
+    querystring: {
+      type: 'object',
+      properties: {
+        repoId: { type: 'string' },
+        branch: { type: 'string' }
+      },
+      required: ['repoId', 'branch']
+    }
+  }
+  fastify.get('/', { schema: getLogSchema }, async (request, reply) => {
+    const { repoId, branch, page } = request.query
+    const onePage = 5
+    const show = Number(page) * onePage || 5
+    const deploy = await Deployment.find({ repoId, branch })
+      .select('-_id -__v -repoId')
+      .sort({ createdAt: 'desc' })
+      .limit(show)
+
+    const finalLogs = deploy.map(d => {
+      const finalLogs = { ...d._doc }
+
+      const updatedAt = dayjs(d.updatedAt).utc()
+
+      finalLogs.took = updatedAt.diff(dayjs(d.createdAt)) / 1000
+      finalLogs.since = updatedAt.fromNow()
+
+      return finalLogs
+    })
+    return finalLogs
+  })
+
+  fastify.get('/:deployId', async (request, reply) => {
+    const { deployId } = request.params
+    try {
+      const logs = await ApplicationLog.find({ deployId })
+        .select('-_id -__v')
+        .sort({ createdAt: 'asc' })
+
+      const deploy = await Deployment.findOne({ deployId })
+        .select('-_id -__v')
+        .sort({ createdAt: 'desc' })
+
+      const finalLogs = {}
+      finalLogs.progress = deploy.progress
+      finalLogs.events = logs.map(log => log.event)
+      finalLogs.human = dayjs(deploy.updatedAt).from(dayjs(deploy.updatedAt))
+      return finalLogs
+    } catch (e) {
+      throw new Error('No logs found')
+    }
+  })
+}
--- a/api/routes/v1/application/logs.js
+++ b/api/routes/v1/application/logs.js
@@ -0,0 +1,10 @@
+const { docker } = require('../../../libs/docker')
+
+module.exports = async function (fastify) {
+  fastify.get('/', async (request, reply) => {
+    const { name } = request.query
+    const service = await docker.engine.getService(`${name}_${name}`)
+    const logs = (await service.logs({ stdout: true, stderr: true, timestamps: true })).toString().split('\n').map(l => l.slice(8)).filter((a) => a)
+    return { logs }
+  })
+}
--- a/api/routes/v1/application/remove.js
+++ b/api/routes/v1/application/remove.js
@@ -0,0 +1,35 @@
+const { docker } = require('../../../libs/docker')
+const { execShellAsync } = require('../../../libs/common')
+const ApplicationLog = require('../../../models/Logs/Application')
+const Deployment = require('../../../models/Deployment')
+
+module.exports = async function (fastify) {
+  fastify.post('/', async (request, reply) => {
+    const { organization, name, branch } = request.body
+    let found = false
+    try {
+      (await docker.engine.listServices()).filter(r => r.Spec.Labels.managedBy === 'coolify' && r.Spec.Labels.type === 'application').map(s => {
+        const running = JSON.parse(s.Spec.Labels.configuration)
+        if (running.repository.organization === organization &&
+          running.repository.name === name &&
+          running.repository.branch === branch) {
+          found = running
+        }
+        return null
+      })
+      if (found) {
+        const deploys = await Deployment.find({ organization, branch, name })
+        for (const deploy of deploys) {
+          await ApplicationLog.deleteMany({ deployId: deploy.deployId })
+          await Deployment.deleteMany({ deployId: deploy.deployId })
+        }
+        await execShellAsync(`docker stack rm ${found.build.container.name}`)
+        reply.code(200).send({ organization, name, branch })
+      } else {
+        reply.code(500).send({ message: 'Nothing to do.' })
+      }
+    } catch (error) {
+      reply.code(500).send({ message: 'Nothing to do.' })
+    }
+  })
+}
--- a/api/routes/v1/config.js
+++ b/api/routes/v1/config.js
@@ -0,0 +1,103 @@
+const { docker } = require('../../libs/docker')
+
+module.exports = async function (fastify) {
+  // const getConfig = {
+  //   querystring: {
+  //     type: 'object',
+  //     properties: {
+  //       repoId: { type: 'number' },
+  //       branch: { type: 'string' }
+  //     },
+  //     required: ['repoId', 'branch']
+  //   }
+  // }
+
+  // const saveConfig = {
+  //   body: {
+  //     type: 'object',
+  //     properties: {
+  //       build: {
+  //         type: 'object',
+  //         properties: {
+  //           baseDir: { type: 'string' },
+  //           installCmd: { type: 'string' },
+  //           buildCmd: { type: 'string' }
+  //         },
+  //         required: ['baseDir', 'installCmd', 'buildCmd']
+  //       },
+  //       publish: {
+  //         type: 'object',
+  //         properties: {
+  //           publishDir: { type: 'string' },
+  //           domain: { type: 'string' },
+  //           pathPrefix: { type: 'string' },
+  //           port: { type: 'number' }
+  //         },
+  //         required: ['publishDir', 'domain', 'pathPrefix', 'port']
+  //       },
+  //       previewDeploy: { type: 'boolean' },
+  //       branch: { type: 'string' },
+  //       repoId: { type: 'number' },
+  //       buildPack: { type: 'string' },
+  //       fullName: { type: 'string' },
+  //       installationId: { type: 'number' }
+  //     },
+  //     required: ['build', 'publish', 'previewDeploy', 'branch', 'repoId', 'buildPack', 'fullName', 'installationId']
+  //   }
+  // }
+
+  // fastify.get("/all", async (request, reply) => {
+  //   return await Config.find().select("-_id -__v");
+  // });
+
+  // fastify.get("/", { schema: getConfig }, async (request, reply) => {
+  //   const { repoId, branch } = request.query;
+  //   return await Config.findOne({ repoId, branch }).select("-_id -__v");
+  // });
+
+  fastify.post('/', async (request, reply) => {
+    const { name, organization, branch } = request.body
+    const services = await docker.engine.listServices()
+    const applications = services.filter(r => r.Spec.Labels.managedBy === 'coolify' && r.Spec.Labels.type === 'application')
+
+    const found = applications.find(r => {
+      const configuration = r.Spec.Labels.configuration ? JSON.parse(r.Spec.Labels.configuration) : null
+      if (branch) {
+        if (configuration.repository.name === name && configuration.repository.organization === organization && configuration.repository.branch === branch) {
+          return r
+        }
+      } else {
+        if (configuration.repository.name === name && configuration.repository.organization === organization) {
+          return r
+        }
+      }
+      return null
+    })
+    if (found) {
+      return JSON.parse(found.Spec.Labels.configuration)
+    } else {
+      reply.code(500).send({ message: 'No configuration found.' })
+    }
+  })
+
+  // fastify.delete("/", async (request, reply) => {
+  //   const { repoId, branch } = request.body;
+
+  //   const deploys = await Deployment.find({ repoId, branch })
+  //   const found = deploys.filter(d => d.progress !== 'done' && d.progress !== 'failed')
+  //   if (found.length > 0) {
+  //     throw new Error('Deployment inprogress, cannot delete now.');
+  //   }
+
+  //   const config = await Config.findOneAndDelete({ repoId, branch })
+  //   for (const deploy of deploys) {
+  //     await ApplicationLog.findOneAndRemove({ deployId: deploy.deployId });
+  //   }
+  //   const secrets = await Secret.find({ repoId, branch });
+  //   for (const secret of secrets) {
+  //     await Secret.findByIdAndRemove(secret._id);
+  //   }
+  //   await execShellAsync(`docker stack rm ${config.containerName}`);
+  //   return { message: 'Deleted application and related configurations.' };
+  // });
+}
--- a/api/routes/v1/dashboard/index.js
+++ b/api/routes/v1/dashboard/index.js
@@ -0,0 +1,55 @@
+const { docker } = require('../../../libs/docker')
+const Deployment = require('../../../models/Deployment')
+const ServerLog = require('../../../models/Logs/Server')
+
+module.exports = async function (fastify) {
+  fastify.get('/', async (request, reply) => {
+    const latestDeployments = await Deployment.aggregate([
+      {
+        $sort: { createdAt: -1 }
+      },
+      {
+        $group:
+        {
+          _id: {
+            repoId: '$repoId',
+            branch: '$branch'
+          },
+          createdAt: { $last: '$createdAt' },
+          progress: { $first: '$progress' }
+        }
+      }
+    ])
+
+    const serverLogs = await ServerLog.find()
+    const services = await docker.engine.listServices()
+
+    let applications = services.filter(r => r.Spec.Labels.managedBy === 'coolify' && r.Spec.Labels.type === 'application' && r.Spec.Labels.configuration)
+    let databases = services.filter(r => r.Spec.Labels.managedBy === 'coolify' && r.Spec.Labels.type === 'database' && r.Spec.Labels.configuration)
+    applications = applications.map(r => {
+      if (JSON.parse(r.Spec.Labels.configuration)) {
+        const configuration = JSON.parse(r.Spec.Labels.configuration)
+        const status = latestDeployments.find(l => configuration.repository.id === l._id.repoId && configuration.repository.branch === l._id.branch)
+        if (status && status.progress) r.progress = status.progress
+        r.Spec.Labels.configuration = configuration
+        return r
+      }
+      return {}
+    })
+    databases = databases.map(r => {
+      const configuration = r.Spec.Labels.configuration ? JSON.parse(r.Spec.Labels.configuration) : null
+      r.Spec.Labels.configuration = configuration
+      return r
+    })
+    applications = [...new Map(applications.map(item => [item.Spec.Labels.configuration.publish.domain, item])).values()]
+    return {
+      serverLogs,
+      applications: {
+        deployed: applications
+      },
+      databases: {
+        deployed: databases
+      }
+    }
+  })
+}
--- a/api/routes/v1/databases/index.js
+++ b/api/routes/v1/databases/index.js
@@ -0,0 +1,173 @@
+const yaml = require('js-yaml')
+const fs = require('fs').promises
+const cuid = require('cuid')
+const { docker } = require('../../../libs/docker')
+const { execShellAsync } = require('../../../libs/common')
+
+const { uniqueNamesGenerator, adjectives, colors, animals } = require('unique-names-generator')
+const generator = require('generate-password')
+
+function getUniq () {
+  return uniqueNamesGenerator({ dictionaries: [adjectives, animals, colors], length: 2 })
+}
+module.exports = async function (fastify) {
+  fastify.get('/:deployId', async (request, reply) => {
+    const { deployId } = request.params
+    try {
+      const database = (await docker.engine.listServices()).find(r => r.Spec.Labels.managedBy === 'coolify' && r.Spec.Labels.type === 'database' && JSON.parse(r.Spec.Labels.configuration).general.deployId === deployId)
+      if (database) {
+        const jsonEnvs = {}
+        for (const d of database.Spec.TaskTemplate.ContainerSpec.Env) {
+          const s = d.split('=')
+          jsonEnvs[s[0]] = s[1]
+        }
+        const payload = {
+          config: JSON.parse(database.Spec.Labels.configuration),
+          envs: jsonEnvs
+        }
+        reply.code(200).send(payload)
+      } else {
+        throw new Error()
+      }
+    } catch (error) {
+      throw new Error('No database found?')
+    }
+  })
+
+  const postSchema = {
+    body: {
+      type: 'object',
+      properties: {
+        type: { type: 'string', enum: ['mongodb', 'postgresql', 'mysql', 'couchdb'] }
+      },
+      required: ['type']
+    }
+  }
+
+  fastify.post('/deploy', { schema: postSchema }, async (request, reply) => {
+    let { type, defaultDatabaseName } = request.body
+    const passwords = generator.generateMultiple(2, {
+      length: 24,
+      numbers: true,
+      strict: true
+    })
+    const usernames = generator.generateMultiple(2, {
+      length: 10,
+      numbers: true,
+      strict: true
+    })
+    // TODO: Query for existing db with the same name
+    const nickname = getUniq()
+
+    if (!defaultDatabaseName) defaultDatabaseName = nickname
+
+    reply.code(201).send({ message: 'Deploying.' })
+    // TODO: Persistent volume, custom inputs
+    const deployId = cuid()
+    const configuration = {
+      general: {
+        workdir: `/tmp/${deployId}`,
+        deployId,
+        nickname,
+        type
+      },
+      database: {
+        usernames,
+        passwords,
+        defaultDatabaseName
+      },
+      deploy: {
+        name: nickname
+      }
+    }
+    let generateEnvs = {}
+    let image = null
+    let volume = null
+    if (type === 'mongodb') {
+      generateEnvs = {
+        MONGODB_ROOT_PASSWORD: passwords[0],
+        MONGODB_USERNAME: usernames[0],
+        MONGODB_PASSWORD: passwords[1],
+        MONGODB_DATABASE: defaultDatabaseName
+      }
+      image = 'bitnami/mongodb:4.4'
+      volume = `${configuration.general.deployId}-${type}-data:/bitnami/mongodb`
+    } else if (type === 'postgresql') {
+      generateEnvs = {
+        POSTGRESQL_PASSWORD: passwords[0],
+        POSTGRESQL_USERNAME: usernames[0],
+        POSTGRESQL_DATABASE: defaultDatabaseName
+      }
+      image = 'bitnami/postgresql:13.2.0'
+      volume = `${configuration.general.deployId}-${type}-data:/bitnami/postgresql`
+    } else if (type === 'couchdb') {
+      generateEnvs = {
+        COUCHDB_PASSWORD: passwords[0],
+        COUCHDB_USER: usernames[0]
+      }
+      image = 'bitnami/couchdb:3'
+      volume = `${configuration.general.deployId}-${type}-data:/bitnami/couchdb`
+    } else if (type === 'mysql') {
+      generateEnvs = {
+        MYSQL_ROOT_PASSWORD: passwords[0],
+        MYSQL_ROOT_USER: usernames[0],
+        MYSQL_USER: usernames[1],
+        MYSQL_PASSWORD: passwords[1],
+        MYSQL_DATABASE: defaultDatabaseName
+      }
+      image = 'bitnami/mysql:8.0'
+      volume = `${configuration.general.deployId}-${type}-data:/bitnami/mysql/data`
+    }
+
+    const stack = {
+      version: '3.8',
+      services: {
+        [configuration.general.deployId]: {
+          image,
+          networks: [`${docker.network}`],
+          environment: generateEnvs,
+          volumes: [volume],
+          deploy: {
+            replicas: 1,
+            update_config: {
+              parallelism: 0,
+              delay: '10s',
+              order: 'start-first'
+            },
+            rollback_config: {
+              parallelism: 0,
+              delay: '10s',
+              order: 'start-first'
+            },
+            labels: [
+              'managedBy=coolify',
+              'type=database',
+              'configuration=' + JSON.stringify(configuration)
+            ]
+          }
+        }
+      },
+      networks: {
+        [`${docker.network}`]: {
+          external: true
+        }
+      },
+      volumes: {
+        [`${configuration.general.deployId}-${type}-data`]: {
+          external: true
+        }
+      }
+    }
+    await execShellAsync(`mkdir -p ${configuration.general.workdir}`)
+    await fs.writeFile(`${configuration.general.workdir}/stack.yml`, yaml.dump(stack))
+    await execShellAsync(
+            `cat ${configuration.general.workdir}/stack.yml | docker stack deploy -c - ${configuration.general.deployId}`
+    )
+  })
+
+  fastify.delete('/:dbName', async (request, reply) => {
+    const { dbName } = request.params
+    await execShellAsync(`docker stack rm ${dbName}`)
+    reply.code(200).send({})
+  })
+}
--- a/api/routes/v1/login/github.js
+++ b/api/routes/v1/login/github.js
@@ -0,0 +1,121 @@
+const axios = require('axios')
+const User = require('../../../models/User')
+const Settings = require('../../../models/Settings')
+const cuid = require('cuid')
+const mongoose = require('mongoose')
+const jwt = require('jsonwebtoken')
+module.exports = async function (fastify) {
+  const githubCodeSchema = {
+    schema: {
+      querystring: {
+        type: 'object',
+        properties: {
+          code: { type: 'string' }
+        },
+        required: ['code']
+      }
+    }
+  }
+  fastify.get('/app', { schema: githubCodeSchema }, async (request, reply) => {
+    const { code } = request.query
+    try {
+      const { data } = await axios({
+        method: 'post',
+        url: `https://github.com/login/oauth/access_token?client_id=${fastify.config.VITE_GITHUB_APP_CLIENTID}&client_secret=${fastify.config.GITHUB_APP_CLIENT_SECRET}&code=${code}`,
+        headers: {
+          accept: 'application/json'
+        }
+      })
+
+      const token = data.access_token
+      const githubAxios = axios.create({
+        baseURL: 'https://api.github.com'
+      })
+
+      githubAxios.defaults.headers.common.Accept = 'Application/json'
+      githubAxios.defaults.headers.common.Authorization = `token ${token}`
+
+      try {
+        let uid = cuid()
+        const { avatar_url } = (await githubAxios.get('/user')).data // eslint-disable-line
+        const email = (await githubAxios.get('/user/emails')).data.filter(
+          (e) => e.primary
+        )[0].email
+        const settings = await Settings.findOne({ applicationName: 'coolify' })
+        const registeredUsers = await User.find().countDocuments()
+        const foundUser = await User.findOne({ email })
+        if (foundUser) {
+          await User.findOneAndUpdate(
+            { email },
+            { avatar: avatar_url },
+            { upsert: true, new: true }
+          )
+          uid = foundUser.uid
+        } else {
+          if (registeredUsers === 0) {
+            const newUser = new User({
+              _id: new mongoose.Types.ObjectId(),
+              email,
+              avatar: avatar_url,
+              uid
+            })
+            try {
+              await newUser.save()
+            } catch (e) {
+              console.log(e)
+              reply.code(500).send({ success: false, error: e })
+              return
+            }
+          } else {
+            if (!settings && registeredUsers > 0) {
+              reply.code(500).send('Registration disabled, enable it in settings.')
+            } else {
+              if (!settings.allowRegistration) {
+                reply.code(500).send('You are not allowed here!')
+              } else {
+                const newUser = new User({
+                  _id: new mongoose.Types.ObjectId(),
+                  email,
+                  avatar: avatar_url,
+                  uid
+                })
+                try {
+                  await newUser.save()
+                } catch (e) {
+                  console.log(e)
+                  reply.code(500).send({ success: false, error: e })
+                  return
+                }
+              }
+            }
+          }
+        }
+        const jwtToken = jwt.sign({}, fastify.config.JWT_SIGN_KEY, {
+          expiresIn: 15778800,
+          algorithm: 'HS256',
+          audience: 'coolLabs',
+          issuer: 'coolLabs',
+          jwtid: uid,
+          subject: `User:${uid}`,
+          notBefore: -1000
+        })
+        reply
+          .code(200)
+          .redirect(
+            302,
+            `/api/v1/login/github/success?jwtToken=${jwtToken}&ghToken=${token}`
+          )
+      } catch (e) {
+        console.log(e)
+        reply.code(500).send({ success: false, error: e })
+        return
+      }
+    } catch (error) {
+      console.log(error)
+      reply.code(500).send({ success: false, error: error.message })
+    }
+  })
+  fastify.get('/success', async (request, reply) => {
+    return reply.sendFile('bye.html')
+  })
+}
--- a/api/routes/v1/settings/index.js
+++ b/api/routes/v1/settings/index.js
@@ -0,0 +1,44 @@
+const Settings = require('../../../models/Settings')
+module.exports = async function (fastify) {
+  const applicationName = 'coolify'
+  const postSchema = {
+    body: {
+      type: 'object',
+      properties: {
+        allowRegistration: { type: 'boolean' }
+      },
+      required: ['allowRegistration']
+    }
+  }
+
+  fastify.get('/', async (request, reply) => {
+    try {
+      let settings = await Settings.findOne({ applicationName }).select('-_id -__v')
+      // TODO: Should do better
+      if (!settings) {
+        settings = {
+          applicationName,
+          allowRegistration: false
+        }
+      }
+      return {
+        settings
+      }
+    } catch (error) {
+      throw new Error(error)
+    }
+  })
+
+  fastify.post('/', { schema: postSchema }, async (request, reply) => {
+    try {
+      const settings = await Settings.findOneAndUpdate(
+        { applicationName },
+        { applicationName, ...request.body },
+        { upsert: true, new: true }
+      ).select('-_id -__v')
+      reply.code(201).send({ settings })
+    } catch (error) {
+      throw new Error(error)
+    }
+  })
+}
--- a/api/routes/v1/undead.js
+++ b/api/routes/v1/undead.js
@@ -0,0 +1,5 @@
+module.exports = async function (fastify) {
+  fastify.get('/', async (request, reply) => {
+    reply.code(200).send('NO')
+  })
+}
--- a/api/routes/v1/upgrade/index.js
+++ b/api/routes/v1/upgrade/index.js
@@ -0,0 +1,12 @@
+const { execShellAsync } = require('../../../libs/common')
+const { saveServerLog } = require('../../../libs/logging')
+
+module.exports = async function (fastify) {
+  fastify.get('/', async (request, reply) => {
+    const upgradeP1 = await execShellAsync('bash ./install.sh upgrade-phase-1')
+    await saveServerLog({ event: upgradeP1, type: 'UPGRADE-P-1' })
+    reply.code(200).send('I\'m trying, okay?')
+    const upgradeP2 = await execShellAsync('bash ./install.sh upgrade-phase-2')
+    await saveServerLog({ event: upgradeP2, type: 'UPGRADE-P-2' })
+  })
+}
--- a/api/routes/v1/verify.js
+++ b/api/routes/v1/verify.js
@@ -0,0 +1,16 @@
+const User = require('../../models/User')
+const jwt = require('jsonwebtoken')
+
+module.exports = async function (fastify) {
+  fastify.get('/', async (request, reply) => {
+    const { authorization } = request.headers
+    if (!authorization) {
+      reply.code(401).send({})
+      return
+    }
+    const token = authorization.split(' ')[1]
+    const verify = jwt.verify(token, fastify.config.JWT_SIGN_KEY)
+    const found = await User.findOne({ uid: verify.jti })
+    found ? reply.code(200).send({}) : reply.code(401).send({})
+  })
+}
--- a/api/routes/v1/webhooks/deploy.js
+++ b/api/routes/v1/webhooks/deploy.js
@@ -0,0 +1,142 @@
+const crypto = require('crypto')
+const { cleanupTmp, execShellAsync } = require('../../../libs/common')
+const Deployment = require('../../../models/Deployment')
+const { queueAndBuild } = require('../../../libs/applications')
+const { setDefaultConfiguration } = require('../../../libs/applications/configuration')
+const { docker } = require('../../../libs/docker')
+const cloneRepository = require('../../../libs/applications/github/cloneRepository')
+
+module.exports = async function (fastify) {
+  // TODO: Add this to fastify plugin
+  const postSchema = {
+    body: {
+      type: 'object',
+      properties: {
+        ref: { type: 'string' },
+        repository: {
+          type: 'object',
+          properties: {
+            id: { type: 'number' },
+            full_name: { type: 'string' }
+          },
+          required: ['id', 'full_name']
+        },
+        installation: {
+          type: 'object',
+          properties: {
+            id: { type: 'number' }
+          },
+          required: ['id']
+        }
+      },
+      required: ['ref', 'repository', 'installation']
+    }
+  }
+  fastify.post('/', { schema: postSchema }, async (request, reply) => {
+    const hmac = crypto.createHmac('sha256', fastify.config.GITHUP_APP_WEBHOOK_SECRET)
+    const digest = Buffer.from('sha256=' + hmac.update(JSON.stringify(request.body)).digest('hex'), 'utf8')
+    const checksum = Buffer.from(request.headers['x-hub-signature-256'], 'utf8')
+    if (checksum.length !== digest.length || !crypto.timingSafeEqual(digest, checksum)) {
+      reply.code(500).send({ error: 'Invalid request' })
+      return
+    }
+
+    if (request.headers['x-github-event'] !== 'push') {
+      reply.code(500).send({ error: 'Not a push event.' })
+      return
+    }
+
+    const services = (await docker.engine.listServices()).filter(r => r.Spec.Labels.managedBy === 'coolify' && r.Spec.Labels.type === 'application')
+
+    let configuration = services.find(r => {
+      if (request.body.ref.startsWith('refs')) {
+        const branch = request.body.ref.split('/')[2]
+        if (
+          JSON.parse(r.Spec.Labels.configuration).repository.id === request.body.repository.id &&
+          JSON.parse(r.Spec.Labels.configuration).repository.branch === branch
+        ) {
+          return r
+        }
+      }
+
+      return null
+    })
+
+    if (!configuration) {
+      reply.code(500).send({ error: 'No configuration found.' })
+      return
+    }
+
+    configuration = setDefaultConfiguration(JSON.parse(configuration.Spec.Labels.configuration))
+
+    await cloneRepository(configuration)
+
+    let foundService = false
+    let foundDomain = false
+    let configChanged = false
+    let imageChanged = false
+
+    let forceUpdate = false
+
+    for (const service of services) {
+      const running = JSON.parse(service.Spec.Labels.configuration)
+      if (running) {
+        if (
+          running.publish.domain === configuration.publish.domain &&
+          running.repository.id !== configuration.repository.id &&
+          running.repository.branch !== configuration.repository.branch
+        ) {
+          foundDomain = true
+        }
+        if (running.repository.id === configuration.repository.id && running.repository.branch === configuration.repository.branch) {
+          const state = await execShellAsync(`docker stack ps ${running.build.container.name} --format '{{ json . }}'`)
+          const isError = state.split('\n').filter(n => n).map(s => JSON.parse(s)).filter(n => n.DesiredState !== 'Running')
+          if (isError.length > 0) forceUpdate = true
+          foundService = true
+
+          const runningWithoutContainer = JSON.parse(JSON.stringify(running))
+          delete runningWithoutContainer.build.container
+
+          const configurationWithoutContainer = JSON.parse(JSON.stringify(configuration))
+          delete configurationWithoutContainer.build.container
+
+          if (JSON.stringify(runningWithoutContainer.build) !== JSON.stringify(configurationWithoutContainer.build) || JSON.stringify(runningWithoutContainer.publish) !== JSON.stringify(configurationWithoutContainer.publish)) configChanged = true
+          if (running.build.container.tag !== configuration.build.container.tag) imageChanged = true
+        }
+      }
+    }
+    if (foundDomain) {
+      cleanupTmp(configuration.general.workdir)
+      reply.code(500).send({ message: 'Domain already used.' })
+      return
+    }
+    if (forceUpdate) {
+      imageChanged = false
+      configChanged = false
+    } else {
+      if (foundService && !imageChanged && !configChanged) {
+        cleanupTmp(configuration.general.workdir)
+        reply.code(500).send({ message: 'Nothing changed, no need to redeploy.' })
+        return
+      }
+    }
+
+    const alreadyQueued = await Deployment.find({
+      repoId: configuration.repository.id,
+      branch: configuration.repository.branch,
+      organization: configuration.repository.organization,
+      name: configuration.repository.name,
+      domain: configuration.publish.domain,
+      progress: { $in: ['queued', 'inprogress'] }
+    })
+
+    if (alreadyQueued.length > 0) {
+      reply.code(200).send({ message: 'Already in the queue.' })
+      return
+    }
+
+    queueAndBuild(configuration, services, configChanged, imageChanged)
+
+    reply.code(201).send({ message: 'Deployment queued.' })
+  })
+}
--- a/api/schema.js
+++ b/api/schema.js
@@ -0,0 +1,49 @@
+const schema = {
+  type: 'object',
+  required: [
+    'DOMAIN',
+    'EMAIL',
+    'VITE_GITHUB_APP_CLIENTID',
+    'GITHUB_APP_CLIENT_SECRET',
+    'GITHUB_APP_PRIVATE_KEY',
+    'GITHUP_APP_WEBHOOK_SECRET',
+    'JWT_SIGN_KEY',
+    'SECRETS_ENCRYPTION_KEY'
+  ],
+  properties: {
+    DOMAIN: {
+      type: 'string'
+    },
+    EMAIL: {
+      type: 'string'
+    },
+    VITE_GITHUB_APP_CLIENTID: {
+      type: 'string'
+    },
+    GITHUB_APP_CLIENT_SECRET: {
+      type: 'string'
+    },
+    GITHUB_APP_PRIVATE_KEY: {
+      type: 'string'
+    },
+    GITHUP_APP_WEBHOOK_SECRET: {
+      type: 'string'
+    },
+    JWT_SIGN_KEY: {
+      type: 'string'
+    },
+    DOCKER_ENGINE: {
+      type: 'string',
+      default: '/var/run/docker.sock'
+    },
+    DOCKER_NETWORK: {
+      type: 'string',
+      default: 'coollabs'
+    },
+    SECRETS_ENCRYPTION_KEY: {
+      type: 'string'
+    }
+  }
+}
+
+module.exports = { schema }
--- a/api/server.js
+++ b/api/server.js
@@ -0,0 +1,90 @@
+require('dotenv').config()
+const fs = require('fs')
+const util = require('util')
+const { saveServerLog } = require('./libs/logging')
+const Deployment = require('./models/Deployment')
+const fastify = require('fastify')({
+  logger: { level: 'error' }
+})
+const mongoose = require('mongoose')
+const path = require('path')
+const { schema } = require('./schema')
+
+fastify.register(require('fastify-env'), {
+  schema,
+  dotenv: true
+})
+
+if (process.env.NODE_ENV === 'production') {
+  fastify.register(require('fastify-static'), {
+    root: path.join(__dirname, '../dist/')
+  })
+
+  fastify.setNotFoundHandler(function (request, reply) {
+    reply.sendFile('index.html')
+  })
+} else {
+  fastify.register(require('fastify-static'), {
+    root: path.join(__dirname, '../public/')
+  })
+}
+
+fastify.register(require('./app'), { prefix: '/api/v1' })
+fastify.setErrorHandler(async (error, request, reply) => {
+  console.log(error)
+  if (error.statusCode) {
+    reply.status(error.statusCode).send({ message: error.message } || { message: 'Something is NOT okay. Are you okay?' })
+  } else {
+    reply.status(500).send({ message: error.message } || { message: 'Something is NOT okay. Are you okay?' })
+  }
+  await saveServerLog({ event: error })
+})
+
+if (process.env.NODE_ENV === 'production') {
+  mongoose.connect(
+    `mongodb://${process.env.MONGODB_USER}:${process.env.MONGODB_PASSWORD}@${process.env.MONGODB_HOST}:${process.env.MONGODB_PORT}/${process.env.MONGODB_DB}?authSource=${process.env.MONGODB_DB}&readPreference=primary&ssl=false`,
+    { useNewUrlParser: true, useUnifiedTopology: true, useFindAndModify: false }
+  )
+} else {
+  mongoose.connect(
+    'mongodb://localhost:27017/coolify?&readPreference=primary&ssl=false',
+    { useNewUrlParser: true, useUnifiedTopology: true, useFindAndModify: false }
+  )
+}
+
+mongoose.connection.on(
+  'error',
+  console.error.bind(console, 'connection error:')
+)
+mongoose.connection.once('open', async function () {
+  if (process.env.NODE_ENV === 'production') {
+    fastify.listen(3000, '0.0.0.0')
+    console.log('Coolify API is up and running in production.')
+  } else {
+    const logFile = fs.createWriteStream('api/development/console.log', { flags: 'w' })
+    const logStdout = process.stdout
+
+    console.log = function (d) {
+      logFile.write(`[INFO]: ${util.format(d)}\n`)
+      logStdout.write(util.format(d) + '\n')
+    }
+
+    console.error = function (d) {
+      logFile.write(`[ERROR]: ${util.format(d)}\n`)
+      logStdout.write(util.format(d) + '\n')
+    }
+
+    console.warn = function (d) {
+      logFile.write(`[WARN]: ${util.format(d)}\n`)
+      logStdout.write(util.format(d) + '\n')
+    }
+
+    fastify.listen(3001)
+    console.log('Coolify API is up and running in development.')
+  }
+  // On start cleanup inprogress/queued deployments.
+  const deployments = await Deployment.find({ progress: { $in: ['queued', 'inprogress'] } })
+  for (const deployment of deployments) {
+    await Deployment.findByIdAndUpdate(deployment._id, { $set: { progress: 'failed' } })
+  }
+})