v1.0.7 (#32)

New features:
- Automatic error reporting (enabled by default)
- Increase build times by leveraging docker build caches
- 
Fixes:
- Fix error handling
- Fix vue autodetect
- Custom dockerfile is not the default

Others:
- Cleanup `logs-servers` collection, because old errors are not standardized
- New Traefik proxy version
- Standardized directory configurations

api/libs/applications/build/container.js

@@ -9,22 +9,12 @@ module.exports = async function (configuration) {
 
   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' }
-    }
+    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)
   } else {
     try {
       await Deployment.findOneAndUpdate(
@@ -33,7 +23,6 @@ module.exports = async function (configuration) {
     } catch (error) {
       // Hmm.
     }
-
-    throw { error: 'No buildpack found.', type: 'app' }
+    throw new Error('No buildpack found.')
   }
 }

api/libs/applications/cleanup/index.js

@@ -3,39 +3,25 @@ const { execShellAsync } = require('../../common')
 const Deployment = require('../../../models/Deployment')
 
 async function purgeImagesContainers () {
-  try {
-    await execShellAsync('docker container prune -f')
-    await execShellAsync('docker image prune -f --filter=label!=coolify-reserve=true')
-  } catch (error) {
-    throw { error, type: 'server' }
-  }
+  await execShellAsync('docker container prune -f')
+  await execShellAsync('docker image prune -f --filter=label!=coolify-reserve=true')
 }
 
-async function cleanupStuckedDeploymentsInDB (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 cleanupStuckedDeploymentsInDB () {
+  // Cleanup stucked deployments.
+  await Deployment.updateMany(
+    { progress: { $in: ['queued', 'inprogress'] } },
+    { progress: 'failed' }
+  )
 }
 
 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' }
-  }
+  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']}`)
+    }
+  })
 }
 
 module.exports = { cleanupStuckedDeploymentsInDB, deleteSameDeployments, purgeImagesContainers }

api/libs/applications/configuration.js

@@ -9,69 +9,64 @@ function getUniq () {
 }
 
 function setDefaultConfiguration (configuration) {
-  try {
-    const nickname = getUniq()
-    const deployId = cuid()
+  const nickname = getUniq()
+  const deployId = cuid()
 
-    const shaBase = JSON.stringify({ repository: configuration.repository })
-    const sha256 = crypto.createHash('sha256').update(shaBase).digest('hex')
+  const shaBase = JSON.stringify({ repository: configuration.repository })
+  const sha256 = crypto.createHash('sha256').update(shaBase).digest('hex')
 
-    const baseServiceConfiguration = {
-      replicas: 1,
-      restart_policy: {
-        condition: 'any',
-        max_attempts: 3
-      },
-      update_config: {
-        parallelism: 1,
-        delay: '10s',
-        order: 'start-first'
-      },
-      rollback_config: {
-        parallelism: 1,
-        delay: '10s',
-        order: 'start-first',
-        failure_action: 'rollback'
-      }
+  const baseServiceConfiguration = {
+    replicas: 1,
+    restart_policy: {
+      condition: 'any',
+      max_attempts: 3
+    },
+    update_config: {
+      parallelism: 1,
+      delay: '10s',
+      order: 'start-first'
+    },
+    rollback_config: {
+      parallelism: 1,
+      delay: '10s',
+      order: 'start-first',
+      failure_action: 'rollback'
     }
-
-    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) {
-      if (configuration.build.pack === 'php') {
-        configuration.publish.port = 80
-      } else if (configuration.build.pack === 'static') {
-        configuration.publish.port = 80
-      } else if (configuration.build.pack === 'nodejs') {
-        configuration.publish.port = 3000
-      } else if (configuration.build.pack === 'rust') {
-        configuration.publish.port = 3000
-      }
-    }
-
-    if (!configuration.build.directory) {
-      configuration.build.directory = '/'
-    }
-    if (!configuration.publish.directory) {
-      configuration.publish.directory = '/'
-    }
-
-    if (configuration.build.pack === 'static' || configuration.build.pack === 'nodejs') {
-      if (!configuration.build.command.installation) configuration.build.command.installation = 'yarn install'
-    }
-
-    configuration.build.container.baseSHA = crypto.createHash('sha256').update(JSON.stringify(baseServiceConfiguration)).digest('hex')
-    configuration.baseServiceConfiguration = baseServiceConfiguration
-
-    return configuration
-  } catch (error) {
-    throw { error, type: 'server' }
   }
+
+  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) {
+    if (configuration.build.pack === 'php') {
+      configuration.publish.port = 80
+    } else if (configuration.build.pack === 'static') {
+      configuration.publish.port = 80
+    } else if (configuration.build.pack === 'nodejs') {
+      configuration.publish.port = 3000
+    } else if (configuration.build.pack === 'rust') {
+      configuration.publish.port = 3000
+    }
+  }
+
+  if (!configuration.build.directory) configuration.build.directory = ''
+  if (configuration.build.directory.startsWith('/')) configuration.build.directory = configuration.build.directory.replace('/', '')
+
+  if (!configuration.publish.directory) configuration.publish.directory = ''
+  if (configuration.publish.directory.startsWith('/')) configuration.publish.directory = configuration.publish.directory.replace('/', '')
+
+  if (configuration.build.pack === 'static' || configuration.build.pack === 'nodejs') {
+    if (!configuration.build.command.installation) configuration.build.command.installation = 'yarn install'
+  }
+
+  configuration.build.container.baseSHA = crypto.createHash('sha256').update(JSON.stringify(baseServiceConfiguration)).digest('hex')
+  configuration.baseServiceConfiguration = baseServiceConfiguration
+
+  return configuration
 }
 
 async function updateServiceLabels (configuration) {
@@ -86,12 +81,8 @@ async function updateServiceLabels (configuration) {
   })
   if (found) {
     const { ID } = found
-    try {
-      const Labels = { ...JSON.parse(found.Spec.Labels.configuration), ...configuration }
-      await 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)
-    }
+    const Labels = { ...JSON.parse(found.Spec.Labels.configuration), ...configuration }
+    await 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}`)
   }
 }
 

api/libs/applications/deploy/copyFiles.js

@@ -59,6 +59,6 @@ module.exports = async function (configuration) {
       )
     }
   } catch (error) {
-    throw { error, type: 'server' }
+    throw new Error(error)
   }
 }

api/libs/applications/deploy/deploy.js

@@ -6,77 +6,71 @@ const { saveAppLog } = require('../../logging')
 const { deleteSameDeployments } = require('../cleanup')
 
 module.exports = async function (configuration, imageChanged) {
-  try {
-    const generateEnvs = {}
-    for (const secret of configuration.publish.secrets) {
-      generateEnvs[secret.name] = secret.value
-    }
-    const containerName = configuration.build.container.name
+  const generateEnvs = {}
+  for (const secret of configuration.publish.secrets) {
+    generateEnvs[secret.name] = secret.value
+  }
+  const containerName = configuration.build.container.name
 
-    // Only save SHA256 of it in the configuration label
-    const baseServiceConfiguration = configuration.baseServiceConfiguration
-    delete configuration.baseServiceConfiguration
+  // Only save SHA256 of it in the configuration label
+  const baseServiceConfiguration = configuration.baseServiceConfiguration
+  delete configuration.baseServiceConfiguration
 
-    const stack = {
-      version: '3.8',
-      services: {
-        [containerName]: {
-          image: `${configuration.build.container.name}:${configuration.build.container.tag}`,
-          networks: [`${docker.network}`],
-          environment: generateEnvs,
-          deploy: {
-            ...baseServiceConfiguration,
-            labels: [
-              'managedBy=coolify',
-              'type=application',
-              'configuration=' + JSON.stringify(configuration),
-              'traefik.enable=true',
-              'traefik.http.services.' +
+  const stack = {
+    version: '3.8',
+    services: {
+      [containerName]: {
+        image: `${configuration.build.container.name}:${configuration.build.container.tag}`,
+        networks: [`${docker.network}`],
+        environment: generateEnvs,
+        deploy: {
+          ...baseServiceConfiguration,
+          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.' +
+            'traefik.http.routers.' +
               configuration.build.container.name +
               '.entrypoints=websecure',
-              'traefik.http.routers.' +
+            'traefik.http.routers.' +
               configuration.build.container.name +
               '.rule=Host(`' +
               configuration.publish.domain +
               '`) && PathPrefix(`' +
               configuration.publish.path +
               '`)',
-              'traefik.http.routers.' +
+            'traefik.http.routers.' +
               configuration.build.container.name +
               '.tls.certresolver=letsencrypt',
-              'traefik.http.routers.' +
+            'traefik.http.routers.' +
               configuration.build.container.name +
               '.middlewares=global-compress'
-            ]
-          }
-        }
-      },
-      networks: {
-        [`${docker.network}`]: {
-          external: true
+          ]
         }
       }
+    },
+    networks: {
+      [`${docker.network}`]: {
+        external: true
+      }
     }
-    await saveAppLog('### Publishing.', configuration)
-    await fs.writeFile(`${configuration.general.workdir}/stack.yml`, yaml.dump(stack))
-    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 or config changed')
-      await deleteSameDeployments(configuration)
-      await execShellAsync(
-        `cat ${configuration.general.workdir}/stack.yml | docker stack deploy --prune -c - ${containerName}`
-      )
-    }
-
-    await saveAppLog('### Published done!', configuration)
-  } catch (error) {
-    console.log(error)
-    await saveAppLog(`Error occured during deployment: ${error.message}`, configuration)
-    throw { error, type: 'server' }
   }
+  await saveAppLog('### Publishing.', configuration)
+  await fs.writeFile(`${configuration.general.workdir}/stack.yml`, yaml.dump(stack))
+  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 or config changed')
+    await deleteSameDeployments(configuration)
+    await execShellAsync(
+        `cat ${configuration.general.workdir}/stack.yml | docker stack deploy --prune -c - ${containerName}`
+    )
+  }
+
+  await saveAppLog('### Published done!', configuration)
 }

api/libs/applications/github/cloneRepository.js

@@ -15,30 +15,24 @@ module.exports = async function (configuration) {
     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(
+  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' }
-  }
+  )
+  configuration.build.container.tag = (
+    await execShellAsync(`cd ${configuration.general.workdir}/ && git rev-parse HEAD`)
+  )
+    .replace('\n', '')
+    .slice(0, 7)
 }

api/libs/applications/index.js

@@ -1,6 +1,5 @@
 const dayjs = require('dayjs')
 
-const { saveServerLog } = require('../logging')
 const { cleanupTmp } = require('../common')
 
 const { saveAppLog } = require('../logging')
@@ -8,37 +7,26 @@ const copyFiles = require('./deploy/copyFiles')
 const buildContainer = require('./build/container')
 const deploy = require('./deploy/deploy')
 const Deployment = require('../../models/Deployment')
-const { cleanupStuckedDeploymentsInDB, purgeImagesContainers } = require('./cleanup')
+const { purgeImagesContainers } = require('./cleanup')
 const { updateServiceLabels } = require('./configuration')
 
 async function queueAndBuild (configuration, 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, imageChanged)
-    await Deployment.findOneAndUpdate(
-      { repoId: id, branch, deployId, organization, name, domain },
-      { repoId: id, branch, deployId, organization, name, domain, progress: 'done' })
-    await updateServiceLabels(configuration)
-    cleanupTmp(workdir)
-    await purgeImagesContainers()
-  } catch (error) {
-    await cleanupStuckedDeploymentsInDB(configuration)
-    cleanupTmp(workdir)
-    const { type } = error.error
-    if (type === 'app') {
-      await saveAppLog(error.error, configuration, true)
-    } else {
-      await saveServerLog({ event: error.error, configuration })
-    }
-  }
+  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, imageChanged)
+  await Deployment.findOneAndUpdate(
+    { repoId: id, branch, deployId, organization, name, domain },
+    { repoId: id, branch, deployId, organization, name, domain, progress: 'done' })
+  await updateServiceLabels(configuration)
+  cleanupTmp(workdir)
+  await purgeImagesContainers()
 }
 
 module.exports = { queueAndBuild }

api/libs/docker.js

@@ -8,24 +8,21 @@ const docker = {
   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
-        }
+  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) {
+        saveAppLog(event.error, configuration, true)
+        reject(event.error)
+      } else if (event.stream) {
         saveAppLog(event.stream, configuration)
       }
-    })
-  } catch (error) {
-    throw { error, type: 'app' }
-  }
+    }
+  })
 }
 
 module.exports = { streamEvents, docker }

api/libs/http-error/handlers.js

@@ -0,0 +1,75 @@
+/* eslint-disable */
+"use strict";   
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleErrors = exports.handleValidationError = exports.handleNotFoundError = void 0;
+const http_errors_enhanced_1 = require("http-errors-enhanced");
+const interfaces_1 = require("./interfaces");
+const utils_1 = require("./utils");
+const validation_1 = require("./validation");
+function handleNotFoundError(request, reply) {
+    handleErrors(new http_errors_enhanced_1.NotFoundError('Not found.'), request, reply);
+}
+exports.handleNotFoundError = handleNotFoundError;
+function handleValidationError(error, request) {
+    /*
+      As seen in https://github.com/fastify/fastify/blob/master/lib/validation.js
+      the error.message will  always start with the relative section (params, querystring, headers, body)
+      and fastify throws on first failing section.
+    */
+    const section = error.message.match(/^\w+/)[0];
+    return new http_errors_enhanced_1.BadRequestError('One or more validations failed trying to process your request.', {
+        failedValidations: validation_1.convertValidationErrors(section, Reflect.get(request, section), error.validation)
+    });
+}
+exports.handleValidationError = handleValidationError;
+function handleErrors(error, request, reply) {
+    var _a, _b;
+    // It is a generic error, handle it
+    const code = error.code;
+    if (!('statusCode' in error)) {
+        if ('validation' in error && ((_a = request[interfaces_1.kHttpErrorsEnhancedConfiguration]) === null || _a === void 0 ? void 0 : _a.convertValidationErrors)) {
+            // If it is a validation error, convert errors to human friendly format
+            error = handleValidationError(error, request);
+        }
+        else if ((_b = request[interfaces_1.kHttpErrorsEnhancedConfiguration]) === null || _b === void 0 ? void 0 : _b.hideUnhandledErrors) {
+            // It is requested to hide the error, just log it and then create a generic one
+            request.log.error({ error: http_errors_enhanced_1.serializeError(error) });
+            error = new http_errors_enhanced_1.InternalServerError('An error occurred trying to process your request.');
+        }
+        else {
+            // Wrap in a HttpError, making the stack explicitily available
+            error = new http_errors_enhanced_1.InternalServerError(http_errors_enhanced_1.serializeError(error));
+            Object.defineProperty(error, 'stack', { enumerable: true });
+        }
+    }
+    else if (code === 'INVALID_CONTENT_TYPE' || code === 'FST_ERR_CTP_INVALID_MEDIA_TYPE') {
+        error = new http_errors_enhanced_1.UnsupportedMediaTypeError(utils_1.upperFirst(validation_1.validationMessagesFormatters.contentType()));
+    }
+    else if (code === 'FST_ERR_CTP_EMPTY_JSON_BODY') {
+        error = new http_errors_enhanced_1.BadRequestError(utils_1.upperFirst(validation_1.validationMessagesFormatters.jsonEmpty()));
+    }
+    else if (code === 'MALFORMED_JSON' || error.message === 'Invalid JSON' || error.stack.includes('at JSON.parse')) {
+        error = new http_errors_enhanced_1.BadRequestError(utils_1.upperFirst(validation_1.validationMessagesFormatters.json()));
+    }
+    // Get the status code
+    let { statusCode, headers } = error;
+    // Code outside HTTP range
+    if (statusCode < 100 || statusCode > 599) {
+        statusCode = http_errors_enhanced_1.INTERNAL_SERVER_ERROR;
+    }
+    // Create the body
+    const body = {
+        statusCode,
+        error: http_errors_enhanced_1.messagesByCodes[statusCode],
+        message: error.message
+    };
+    http_errors_enhanced_1.addAdditionalProperties(body, error);
+    // Send the error back
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    reply
+        .code(statusCode)
+        .headers(headers !== null && headers !== void 0 ? headers : {})
+        .type('application/json')
+        .send(body);
+}
+exports.handleErrors = handleErrors;

api/libs/http-error/index.js

@@ -0,0 +1,58 @@
+/* eslint-disable */
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = exports.validationMessagesFormatters = exports.niceJoin = exports.convertValidationErrors = void 0;
+const fastify_plugin_1 = __importDefault(require("fastify-plugin"));
+const handlers_1 = require("./handlers");
+const interfaces_1 = require("./interfaces");
+const validation_1 = require("./validation");
+__exportStar(require("./handlers"), exports);
+__exportStar(require("./interfaces"), exports);
+var validation_2 = require("./validation");
+Object.defineProperty(exports, "convertValidationErrors", { enumerable: true, get: function () { return validation_2.convertValidationErrors; } });
+Object.defineProperty(exports, "niceJoin", { enumerable: true, get: function () { return validation_2.niceJoin; } });
+Object.defineProperty(exports, "validationMessagesFormatters", { enumerable: true, get: function () { return validation_2.validationMessagesFormatters; } });
+exports.plugin = fastify_plugin_1.default(function (instance, options, done) {
+    var _a, _b, _c, _d;
+    const isProduction = process.env.NODE_ENV === 'production';
+    const convertResponsesValidationErrors = (_a = options.convertResponsesValidationErrors) !== null && _a !== void 0 ? _a : !isProduction;
+    const configuration = {
+        hideUnhandledErrors: (_b = options.hideUnhandledErrors) !== null && _b !== void 0 ? _b : isProduction,
+        convertValidationErrors: (_c = options.convertValidationErrors) !== null && _c !== void 0 ? _c : true,
+        responseValidatorCustomizer: options.responseValidatorCustomizer,
+        allowUndeclaredResponses: (_d = options.allowUndeclaredResponses) !== null && _d !== void 0 ? _d : false
+    };
+    instance.decorate(interfaces_1.kHttpErrorsEnhancedConfiguration, null);
+    instance.decorateRequest(interfaces_1.kHttpErrorsEnhancedConfiguration, null);
+    instance.addHook('onRequest', async (request) => {
+        request[interfaces_1.kHttpErrorsEnhancedConfiguration] = configuration;
+    });
+    instance.setErrorHandler(handlers_1.handleErrors);
+    // instance.setNotFoundHandler(handlers_1.handleNotFoundError);
+    if (convertResponsesValidationErrors) {
+        instance.decorate(interfaces_1.kHttpErrorsEnhancedResponseValidations, []);
+        instance.addHook('onRoute', validation_1.addResponseValidation);
+        instance.addHook('onReady', validation_1.compileResponseValidationSchema.bind(instance, configuration));
+    }
+    done();
+}, { name: 'fastify-http-errors-enhanced' });
+exports.default = exports.plugin;
+// Fix CommonJS exporting
+/* istanbul ignore else */
+if (typeof module !== 'undefined') {
+    module.exports = exports.plugin;
+    Object.assign(module.exports, exports);
+}

api/libs/http-error/interfaces.js

@@ -0,0 +1,6 @@
+/* eslint-disable */
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kHttpErrorsEnhancedResponseValidations = exports.kHttpErrorsEnhancedConfiguration = void 0;
+exports.kHttpErrorsEnhancedConfiguration = Symbol('fastify-http-errors-enhanced-configuration');
+exports.kHttpErrorsEnhancedResponseValidations = Symbol('fastify-http-errors-enhanced-response-validation');

api/libs/http-error/utils.js

@@ -0,0 +1,31 @@
+/* eslint-disable */
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.get = exports.upperFirst = void 0;
+function upperFirst(source) {
+    if (typeof source !== 'string' || !source.length) {
+        return source;
+    }
+    return source[0].toUpperCase() + source.substring(1);
+}
+exports.upperFirst = upperFirst;
+function get(target, path) {
+    var _a;
+    const tokens = path.split('.').map((t) => t.trim());
+    for (const token of tokens) {
+        if (typeof target === 'undefined' || target === null) {
+            // We're supposed to be still iterating, but the chain is over - Return undefined
+            target = undefined;
+            break;
+        }
+        const index = token.match(/^(\d+)|(?:\[(\d+)\])$/);
+        if (index) {
+            target = target[parseInt((_a = index[1]) !== null && _a !== void 0 ? _a : index[2], 10)];
+        }
+        else {
+            target = target[token];
+        }
+    }
+    return target;
+}
+exports.get = get;

api/libs/http-error/validation.js

@@ -0,0 +1,239 @@
+/* eslint-disable */
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileResponseValidationSchema = exports.addResponseValidation = exports.convertValidationErrors = exports.validationMessagesFormatters = exports.niceJoin = void 0;
+const ajv_1 = __importDefault(require("ajv"));
+const http_errors_enhanced_1 = require("http-errors-enhanced");
+const interfaces_1 = require("./interfaces");
+const utils_1 = require("./utils");
+function niceJoin(array, lastSeparator = ' and ', separator = ', ') {
+    switch (array.length) {
+        case 0:
+            return '';
+        case 1:
+            return array[0];
+        case 2:
+            return array.join(lastSeparator);
+        default:
+            return array.slice(0, array.length - 1).join(separator) + lastSeparator + array[array.length - 1];
+    }
+}
+exports.niceJoin = niceJoin;
+exports.validationMessagesFormatters = {
+    contentType: () => 'only JSON payloads are accepted. Please set the "Content-Type" header to start with "application/json"',
+    json: () => 'the body payload is not a valid JSON',
+    jsonEmpty: () => 'the JSON body payload cannot be empty if the "Content-Type" header is set',
+    missing: () => 'must be present',
+    unknown: () => 'is not a valid property',
+    uuid: () => 'must be a valid GUID (UUID v4)',
+    timestamp: () => 'must be a valid ISO 8601 / RFC 3339 timestamp (example: 2018-07-06T12:34:56Z)',
+    date: () => 'must be a valid ISO 8601 / RFC 3339 date (example: 2018-07-06)',
+    time: () => 'must be a valid ISO 8601 / RFC 3339 time (example: 12:34:56)',
+    uri: () => 'must be a valid URI',
+    hostname: () => 'must be a valid hostname',
+    ipv4: () => 'must be a valid IPv4',
+    ipv6: () => 'must be a valid IPv6',
+    paramType: (type) => {
+        switch (type) {
+            case 'integer':
+                return 'must be a valid integer number';
+            case 'number':
+                return 'must be a valid number';
+            case 'boolean':
+                return 'must be a valid boolean (true or false)';
+            case 'object':
+                return 'must be a object';
+            case 'array':
+                return 'must be an array';
+            default:
+                return 'must be a string';
+        }
+    },
+    presentString: () => 'must be a non empty string',
+    minimum: (min) => `must be a number greater than or equal to ${min}`,
+    maximum: (max) => `must be a number less than or equal to ${max}`,
+    minimumProperties(min) {
+        return min === 1 ? 'cannot be a empty object' : `must be a object with at least ${min} properties`;
+    },
+    maximumProperties(max) {
+        return max === 0 ? 'must be a empty object' : `must be a object with at most ${max} properties`;
+    },
+    minimumItems(min) {
+        return min === 1 ? 'cannot be a empty array' : `must be an array with at least ${min} items`;
+    },
+    maximumItems(max) {
+        return max === 0 ? 'must be a empty array' : `must be an array with at most ${max} items`;
+    },
+    enum: (values) => `must be one of the following values: ${niceJoin(values.map((f) => `"${f}"`), ' or ')}`,
+    pattern: (pattern) => `must match pattern "${pattern.replace(/\(\?:/g, '(')}"`,
+    invalidResponseCode: (code) => `This endpoint cannot respond with HTTP status ${code}.`,
+    invalidResponse: (code) => `The response returned from the endpoint violates its specification for the HTTP status ${code}.`,
+    invalidFormat: (format) => `must match format "${format}" (format)`
+};
+function convertValidationErrors(section, data, validationErrors) {
+    const errors = {};
+    if (section === 'querystring') {
+        section = 'query';
+    }
+    // For each error
+    for (const e of validationErrors) {
+        let message = '';
+        let pattern;
+        let value;
+        let reason;
+        // Normalize the key
+        let key = e.dataPath;
+        if (key.startsWith('.')) {
+            key = key.substring(1);
+        }
+        // Remove useless quotes
+        /* istanbul ignore next */
+        if (key.startsWith('[') && key.endsWith(']')) {
+            key = key.substring(1, key.length - 1);
+        }
+        // Depending on the type
+        switch (e.keyword) {
+            case 'required':
+            case 'dependencies':
+                key = e.params.missingProperty;
+                message = exports.validationMessagesFormatters.missing();
+                break;
+            case 'additionalProperties':
+                key = e.params.additionalProperty;
+                message = exports.validationMessagesFormatters.unknown();
+                break;
+            case 'type':
+                message = exports.validationMessagesFormatters.paramType(e.params.type);
+                break;
+            case 'minProperties':
+                message = exports.validationMessagesFormatters.minimumProperties(e.params.limit);
+                break;
+            case 'maxProperties':
+                message = exports.validationMessagesFormatters.maximumProperties(e.params.limit);
+                break;
+            case 'minItems':
+                message = exports.validationMessagesFormatters.minimumItems(e.params.limit);
+                break;
+            case 'maxItems':
+                message = exports.validationMessagesFormatters.maximumItems(e.params.limit);
+                break;
+            case 'minimum':
+                message = exports.validationMessagesFormatters.minimum(e.params.limit);
+                break;
+            case 'maximum':
+                message = exports.validationMessagesFormatters.maximum(e.params.limit);
+                break;
+            case 'enum':
+                message = exports.validationMessagesFormatters.enum(e.params.allowedValues);
+                break;
+            case 'pattern':
+                pattern = e.params.pattern;
+                value = utils_1.get(data, key);
+                if (pattern === '.+' && !value) {
+                    message = exports.validationMessagesFormatters.presentString();
+                }
+                else {
+                    message = exports.validationMessagesFormatters.pattern(e.params.pattern);
+                }
+                break;
+            case 'format':
+                reason = e.params.format;
+                // Normalize the key
+                if (reason === 'date-time') {
+                    reason = 'timestamp';
+                }
+                message = (exports.validationMessagesFormatters[reason] || exports.validationMessagesFormatters.invalidFormat)(reason);
+                break;
+        }
+        // No custom message was found, default to input one replacing the starting verb and adding some path info
+        if (!message.length) {
+            message = `${e.message.replace(/^should/, 'must')} (${e.keyword})`;
+        }
+        // Remove useless quotes
+        /* istanbul ignore next */
+        if (key.match(/(?:^['"])(?:[^.]+)(?:['"]$)/)) {
+            key = key.substring(1, key.length - 1);
+        }
+        // Fix empty properties
+        if (!key) {
+            key = '$root';
+        }
+        key = key.replace(/^\//, '');
+        errors[key] = message;
+    }
+    return { [section]: errors };
+}
+exports.convertValidationErrors = convertValidationErrors;
+function addResponseValidation(route) {
+    var _a;
+    if (!((_a = route.schema) === null || _a === void 0 ? void 0 : _a.response)) {
+        return;
+    }
+    const validators = {};
+    /*
+      Add these validators to the list of the one to compile once the server is started.
+      This makes possible to handle shared schemas.
+    */
+    this[interfaces_1.kHttpErrorsEnhancedResponseValidations].push([
+        this,
+        validators,
+        Object.entries(route.schema.response)
+    ]);
+    // Note that this hook is not called for non JSON payloads therefore validation is not possible in such cases
+    route.preSerialization = async function (request, reply, payload) {
+        const statusCode = reply.raw.statusCode;
+        // Never validate error 500
+        if (statusCode === http_errors_enhanced_1.INTERNAL_SERVER_ERROR) {
+            return payload;
+        }
+        // No validator, it means the HTTP status is not allowed
+        const validator = validators[statusCode];
+        if (!validator) {
+            if (request[interfaces_1.kHttpErrorsEnhancedConfiguration].allowUndeclaredResponses) {
+                return payload;
+            }
+            throw new http_errors_enhanced_1.InternalServerError(exports.validationMessagesFormatters.invalidResponseCode(statusCode));
+        }
+        // Now validate the payload
+        const valid = validator(payload);
+        if (!valid) {
+            throw new http_errors_enhanced_1.InternalServerError(exports.validationMessagesFormatters.invalidResponse(statusCode), {
+                failedValidations: convertValidationErrors('response', payload, validator.errors)
+            });
+        }
+        return payload;
+    };
+}
+exports.addResponseValidation = addResponseValidation;
+function compileResponseValidationSchema(configuration) {
+    // Fix CJS/ESM interoperability
+    // @ts-expect-error
+    let AjvConstructor = ajv_1.default;
+    /* istanbul ignore next */
+    if (AjvConstructor.default) {
+        AjvConstructor = AjvConstructor.default;
+    }
+    const hasCustomizer = typeof configuration.responseValidatorCustomizer === 'function';
+    for (const [instance, validators, schemas] of this[interfaces_1.kHttpErrorsEnhancedResponseValidations]) {
+        // @ts-expect-error
+        const compiler = new AjvConstructor({
+            // The fastify defaults, with the exception of removeAdditional and coerceTypes, which have been reversed
+            removeAdditional: false,
+            useDefaults: true,
+            coerceTypes: false,
+            allErrors: true
+        });
+        compiler.addSchema(Object.values(instance.getSchemas()));
+        compiler.addKeyword('example');
+        if (hasCustomizer) {
+            configuration.responseValidatorCustomizer(compiler);
+        }
+        for (const [code, schema] of schemas) {
+            validators[code] = compiler.compile(schema);
+        }
+    }
+}
+exports.compileResponseValidationSchema = compileResponseValidationSchema;

api/libs/logging.js

@@ -1,10 +1,18 @@
+const dayjs = require('dayjs')
+const axios = require('axios')
+
 const ApplicationLog = require('../models/Logs/Application')
 const ServerLog = require('../models/Logs/Server')
-const dayjs = require('dayjs')
+const Settings = require('../models/Settings')
+const { version } = require('../../package.json')
 
 function generateTimestamp () {
   return `${dayjs().format('YYYY-MM-DD HH:mm:ss.SSS')} `
 }
+const patterns = [
+  '[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)',
+  '(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))'
+].join('|')
 
 async function saveAppLog (event, configuration, isError) {
   try {
@@ -12,25 +20,12 @@ async function saveAppLog (event, configuration, isError) {
     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)
-      }
+      const clearedEvent = '[ERROR 😱] ' + generateTimestamp() + event.replace(new RegExp(patterns, 'g'), '').replace(/(\r\n|\n|\r)/gm, '')
+      await new ApplicationLog({ repoId, branch, deployId, event: clearedEvent }).save()
     } 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)
-        }
+        const clearedEvent = '[INFO] ' + generateTimestamp() + event.replace(new RegExp(patterns, 'g'), '').replace(/(\r\n|\n|\r)/gm, '')
+        await new ApplicationLog({ repoId, branch, deployId, event: clearedEvent }).save()
       }
     }
   } catch (error) {
@@ -39,20 +34,14 @@ async function saveAppLog (event, configuration, isError) {
   }
 }
 
-async function saveServerLog ({ event, configuration, type }) {
-  try {
-    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()
-  } catch (error) {
-    // Hmm.
-  }
-}
+async function saveServerLog (error) {
+  const settings = await Settings.findOne({ applicationName: 'coolify' })
+  const payload = { message: error.message, stack: error.stack, type: error.type || 'spaghetticode', version }
 
+  const found = await ServerLog.find(payload)
+  if (found.length === 0 && error.message) await new ServerLog(payload).save()
+  if (settings && settings.sendErrors && process.env.NODE_ENV === 'production') await axios.post('https://errors.coollabs.io/api/error', payload)
+}
 module.exports = {
   saveAppLog,
   saveServerLog