fix: forgot that the version bump changed 😅

* New Version: 3.0.0

.devcontainer/Dockerfile

@@ -0,0 +1,16 @@
+# See here for image contents: https://github.com/microsoft/vscode-dev-containers/tree/v0.233.0/containers/javascript-node/.devcontainer/base.Dockerfile
+
+# [Choice] Node.js version (use -bullseye variants on local arm64/Apple Silicon): 18, 16, 14, 18-bullseye, 16-bullseye, 14-bullseye, 18-buster, 16-buster, 14-buster
+ARG VARIANT="16-bullseye"
+FROM mcr.microsoft.com/vscode/devcontainers/javascript-node:0-${VARIANT}
+
+# [Optional] Uncomment this section to install additional OS packages.
+# RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
+#     && apt-get -y install --no-install-recommends <your-package-list-here>
+
+# [Optional] Uncomment if you want to install an additional version of node using nvm
+# ARG EXTRA_NODE_VERSION=10
+# RUN su node -c "source /usr/local/share/nvm/nvm.sh && nvm install ${EXTRA_NODE_VERSION}"
+
+# [Optional] Uncomment if you want to install more global node modules
+RUN su node -c "npm install -g pnpm"

.devcontainer/devcontainer.json

@@ -0,0 +1,28 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the README at:
+// https://github.com/microsoft/vscode-dev-containers/tree/v0.233.0/containers/javascript-node
+{
+	"name": "Node.js",
+	"build": {
+		"dockerfile": "Dockerfile",
+		// Update 'VARIANT' to pick a Node version: 18, 16, 14.
+		// Append -bullseye or -buster to pin to an OS version.
+		// Use -bullseye variants on local arm64/Apple Silicon.
+		"args": {
+			"VARIANT": "16-bullseye"
+		}
+	},
+	// Set *default* container specific settings.json values on container create.
+	"settings": {},
+	// Add the IDs of extensions you want installed when the container is created.
+	"extensions": ["dbaeumer.vscode-eslint", "svelte.svelte-vscode"],
+	// Use 'forwardPorts' to make a list of ports inside the container available locally.
+	"forwardPorts": [3000],
+	// Use 'postCreateCommand' to run commands after the container is created.
+	"postCreateCommand": "cp .env.template .env && pnpm install && pnpm db:push && pnpm db:seed",
+	// Comment out to connect as root instead. More info: https://aka.ms/vscode-remote/containers/non-root.
+	"remoteUser": "node",
+	"features": {
+		"docker-in-docker": "20.10",
+		"github-cli": "latest"
+	}
+}

.dockerignore

@@ -1,3 +1,11 @@
+.DS_Store
 node_modules
+build
+.svelte-kit
+package
+.env
+.env.*
+!.env.example
 dist
-.routify
+client
+apps/api/db/*.db

.env.template

@@ -1,35 +0,0 @@
-####################################
-# Domain where your Coolify instance will be available and reachable.
-# It's the same as you set in Github OAuth App and Github App as <domain>.
-DOMAIN=
-## Let's Encrypt contact email required
-EMAIL=
-
-# JWT Token Sign Key for logging you in to Coolify's frontend
-JWT_SIGN_KEY=
-# Encryption key for SECRETS - do NOT share it with others!
-SECRETS_ENCRYPTION_KEY=
-
-# Docker Engine
-DOCKER_ENGINE=/var/run/docker.sock
-# Docker network to use internally between the proxy and your apps
-DOCKER_NETWORK=coollabs
-
-# Mongodb
-# Values in case if you are using our Mongodb installation - CHANGE user and password fields!
-MONGODB_HOST=coollabs-mongodb
-MONGODB_PORT=27017
-MONGODB_USER=supercooldbuser
-MONGODB_PASSWORD=developmentPassword4db
-MONGODB_DB=coolLabs-prod
-
-# Frontend only variables
-VITE_GITHUB_APP_CLIENTID=
-VITE_GITHUB_APP_NAME=
-
-# Github OAuth & App secrets and private key - you can get it from Github.
-GITHUB_APP_CLIENT_SECRET=
-GITHUP_APP_WEBHOOK_SECRET=
-
-# It should look like this. Newlines breaks with \n
-GITHUB_APP_PRIVATE_KEY="-----BEGIN RSA PRIVATE KEY-----\nMIIEowIBAAKCAQEA7Y+Uwkd8FINSwFktWGdtwCaOAazTDYR8ucEzGyR9r+ooJZhF\nOc32qgDSps6Q5DsqPOzvfhiviqU+et9VF+bJhfdzwJ+Le86QZH1RgsDMoY049XvI\nKSwP........"

.github/FUNDING.yml

@@ -0,0 +1 @@
+open_collective: coollabsio

.github/ISSUE_TEMPLATE/--bug-report.yaml

@@ -0,0 +1,47 @@
+name: 🐞 Bug report
+description: Create a bug report to help us improve coolify
+title: "[Bug]: "
+labels: [Bug]
+assignees:
+- andrasbacsai
+- vasani-arpit
+body:
+- type: markdown
+  attributes:
+    value: |
+      Thanks for taking the time to fill out this bug report! Please fill the form in English
+- type: checkboxes
+  attributes:
+    label: Is there an existing issue for this?
+    options:
+    - label: I have searched the existing issues
+      required: true
+- type: textarea
+  attributes:
+    label: Description
+    description: A concise description of what you're experiencing and what you expect.
+    placeholder: |
+      When I do <X>, <Y> happens and I see the error message attached below:
+      ```...```
+      What I expect is <Z>
+  validations:
+    required: true
+- type: textarea
+  attributes:
+    label: Steps To Reproduce
+    description: Add steps to reproduce this behaviour, include console / network logs & videos
+    placeholder: |
+      1. Go to '...'
+      2. Click on '....'
+      3. Scroll down to '....'
+      4. See error
+  validations:
+    required: true
+- type: input
+  id: version
+  attributes:
+    label: Version
+    description: "The version of your coolify Instance"
+    placeholder: "2.5.2"
+  validations:
+    required: true

.github/ISSUE_TEMPLATE/--feature-request.yaml

@@ -0,0 +1,31 @@
+name: 🛠️ Feature request
+description: Suggest an idea to improve coolify
+title: '[Feature]: '
+labels: [Enhancement]
+assignees:
+  - andrasbacsai
+  - vasani-arpit
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for taking the time to request a feature for coolify! Please also add your request here to get feedback from the community: https://feedback.coolify.io/!
+  - type: checkboxes
+    attributes:
+      label: Is there an existing issue for this?
+      description: Please search to see if an issue related to this feature request already exists.
+      options:
+        - label: I have searched the existing issues
+          required: true
+  - type: textarea
+    attributes:
+      label: Summary
+      description: One paragraph description of the feature.
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Why should this be worked on?
+      description: A concise description of the problems or use cases for this feature request.
+    validations:
+      required: true

.github/ISSUE_TEMPLATE/--task.yaml

@@ -0,0 +1,20 @@
+name: 📝 Task
+description: Create a task for the team to work on
+title: "[Task]: "
+labels: [Task]
+body:
+- type: checkboxes
+  attributes:
+    label: Is there an existing issue for this?
+    description: Please search to see if an issue related to this already exists.
+    options:
+    - label: I have searched the existing issues
+      required: true
+- type: textarea
+  attributes:
+    label: SubTasks 
+    placeholder: |
+      - Sub Task 1
+      - Sub Task 2
+  validations:
+    required: false

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,8 @@
+blank_issues_enabled: true
+contact_links:
+  - name: 🤔 Questions and Help
+    url: https://discord.com/invite/6rDM4fkymF
+    about: Reach out to us on discord or our github discussions page.
+  - name: 🙋‍♂️ service request
+    url: https://feedback.coolify.io/
+    about: want to request a new service? for e.g wordpress, hasura, appwrite etc...

.github/workflows/github-actions.yml

@@ -0,0 +1,39 @@
+name: release-coolify
+
+on:
+  release:
+    types: published
+
+jobs:
+  make-it-coolifyed:
+    runs-on: ubuntu-latest
+    steps:
+       -
+        name: Checkout
+        uses: actions/checkout@v2
+       - 
+        name: Set up QEMU
+        uses: docker/setup-qemu-action@v1
+       -
+        name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v1
+       -
+        name: Login to DockerHub
+        uses: docker/login-action@v1 
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+       - 
+         name: Get current package version
+         uses: martinbeentjes/npm-get-version-action@v1.2.3
+         id: package-version
+       -
+        name: Build and push
+        uses: docker/build-push-action@v2
+        with:
+          context: .
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: coollabsio/coolify:latest,coollabsio/coolify:${{steps.package-version.outputs.current-version}}
+          cache-from: type=registry,ref=coollabsio/coolify:buildcache
+          cache-to: type=registry,ref=coollabsio/coolify:buildcache,mode=max

.gitignore

@@ -1,10 +1,11 @@
-.vscode
-.idea
+.DS_Store
 node_modules
-dist
-dist-ssr
-.routify
+build
+.svelte-kit
+package
 .env
-yarn-error.log
-api/development/console.log
-.pnpm-debug.log
+.env.*
+!.env.example
+dist
+client
+apps/api/db/*.db

.gitpod.yml

@@ -0,0 +1,9 @@
+# This configuration file was automatically generated by Gitpod.
+# Please adjust to your needs (see https://www.gitpod.io/docs/config-gitpod-file)
+# and commit this file to your remote git repository to share the goodness with others.
+
+tasks:
+  - init: npm install && npm run build
+    command: npm run start
+
+

.prettierrc

@@ -1,14 +0,0 @@
-{
-    "arrowParens": "avoid",
-    "bracketSpacing": true,
-    "printWidth": 80,
-    "semi": true,
-    "singleQuote": false,
-    "tabWidth": 2,
-    "trailingComma": "all",
-    "svelteSortOrder" : "styles-scripts-markup",
-    "svelteStrictMode": true,
-    "svelteBracketNewLine": true,
-    "svelteAllowShorthand": true,
-    "plugins": ["prettier-plugin-svelte"]
-  }

.vscode/settings.json

@@ -0,0 +1,11 @@
+{
+	"i18n-ally.localesPaths": ["src/lib/locales"],
+	"i18n-ally.keystyle": "nested",
+	"i18n-ally.extract.ignoredByFiles": {
+		"src\\routes\\__layout.svelte": ["Coolify", "coolLabs logo"]
+	},
+	"i18n-ally.sourceLanguage": "en",
+	"i18n-ally.enabledFrameworks": ["svelte"],
+	"i18n-ally.enabledParsers": ["js", "ts", "json"],
+	"i18n-ally.extract.autoDetect": true
+}

CONTRIBUTING.md

@@ -0,0 +1,281 @@
+# 👋 Welcome
+
+First of all, thank you for considering contributing to my project! It means a lot 💜.
+
+Contribution guide is for v2, not applicable for v3
+
+## 🙋 Want to help?
+
+If you begin in GitHub contribution, you can find the [first contribution](https://github.com/firstcontributions/first-contributions) and follow this guide.
+
+Follow the [introduction](#introduction) to get started then start contributing!
+
+This is a little list of what you can do to help the project:
+
+- [🧑‍💻 Develop your own ideas](#developer-contribution)
+- [🌐 Translate the project](#translation)
+
+## 👋 Introduction
+
+### Setup with github codespaces
+
+If you have github codespaces enabled then you can just create a codespace and run `pnpm dev` to run your the dev environment. All the required dependencies and packages has been configured for you already.
+
+### Setup locally in your machine
+
+> 🔴 At the moment, Coolify **doesn't support Windows**. You must use Linux or MacOS. 💡 Although windows users can use github codespaces for development
+
+#### Recommended Pull Request Guideline
+
+- Fork the project
+- Clone your fork repo to local
+- Create a new branch
+- Push to your fork repo
+- Create a pull request: https://github.com/coollabsio/compare
+- Write a proper description
+- Open the pull request to review against `next` branch
+
+---
+
+# How to start after you set up your local fork?
+
+Due to the lock file, this repository is best with [pnpm](https://pnpm.io). I recommend you try and use `pnpm` because it is cool and efficient!
+
+You need to have [Docker Engine](https://docs.docker.com/engine/install/) installed locally.
+
+#### Steps for local setup
+
+1. Copy `.env.template` to `.env` and set the `COOLIFY_APP_ID` environment variable to something cool.
+2. Install dependencies with `pnpm install`.
+3. Need to create a local SQlite database with `pnpm db:push`.
+
+   This will apply all migrations at `db/dev.db`.
+
+4. Seed the database with base entities with `pnpm db:seed`
+5. You can start coding after starting `pnpm dev`.
+
+## 🧑‍💻 Developer contribution
+
+### Technical skills required
+
+- **Languages**: Node.js / Javascript / Typescript
+- **Framework JS/TS**: Svelte / SvelteKit
+- **Database ORM**: Prisma.io
+- **Docker Engine**
+
+### Database migrations
+
+During development, if you change the database layout, you need to run `pnpm db:push` to migrate the database and create types for Prisma. You also need to restart the development process.
+
+If the schema is finalized, you need to create a migration file with `pnpm db:migrate <nameOfMigration>` where `nameOfMigration` is given by you. Make it sense. :)
+
+### Tricky parts
+
+- BullMQ, the queue system Coolify uses, cannot be hot reloaded. So if you change anything in the files related to it, you need to restart the development process. I'm actively looking for a different queue/scheduler library. I'm open to discussion!
+
+---
+
+# How to add new services
+
+You can add any open-source and self-hostable software (service/application) to Coolify if the following statements are true:
+
+- Self-hostable (obviously)
+- Open-source
+- Maintained (I do not want to add software full of bugs)
+
+## Backend
+
+There are 5 steps you should make on the backend side.
+
+1. Create Prisma / database schema for the new service.
+2. Add supported versions of the service.
+3. Update global functions.
+4. Create API endpoints.
+5. Define automatically generated variables.
+
+> I will use [Umami](https://umami.is/) as an example service.
+
+### Create Prisma / database schema for the new service.
+
+You only need to do this if you store passwords or any persistent configuration. Mostly it is required by all services, but there are some exceptions, like NocoDB.
+
+Update Prisma schema in [prisma/schema.prisma](prisma/schema.prisma).
+
+- Add new model with the new service name.
+- Make a relationshup with `Service` model.
+- In the `Service` model, the name of the new field should be with low-capital.
+- If the service needs a database, define a `publicPort` field to be able to make it's database public, example field name in case of PostgreSQL: `postgresqlPublicPort`. It should be a optional field.
+
+If you are finished with the Prisma schema, you should update the database schema with `pnpm db:push` command.
+
+> You must restart the running development environment to be able to use the new model
+
+> If you use VSCode, you probably need to restart the `Typescript Language Server` to get the new types loaded in the running VSCode.
+
+### Add supported versions
+
+Supported versions are hardcoded into Coolify (for now).
+
+You need to update `supportedServiceTypesAndVersions` function at [src/lib/components/common.ts](src/lib/components/common.ts). Example JSON:
+
+```js
+     {
+       // Name used to identify the service internally
+       name: 'umami',
+       // Fancier name to show to the user
+       fancyName: 'Umami',
+       // Docker base image for the service
+       baseImage: 'ghcr.io/mikecao/umami',
+       // Optional: If there is any dependent image, you should list it here
+       images: [],
+       // Usable tags
+       versions: ['postgresql-latest'],
+       // Which tag is the recommended
+       recommendedVersion: 'postgresql-latest',
+       // Application's default port, Umami listens on 3000
+       ports: {
+         main: 3000
+       }
+     }
+```
+
+### Update global functions
+
+1. Add the new service to the `include` variable in [src/lib/database/services.ts](src/lib/database/services.ts), so it will be included in all places in the database queries where it is required.
+
+```js
+const include: Prisma.ServiceInclude = {
+	destinationDocker: true,
+	persistentStorage: true,
+	serviceSecret: true,
+	minio: true,
+	plausibleAnalytics: true,
+	vscodeserver: true,
+	wordpress: true,
+	ghost: true,
+	meiliSearch: true,
+	umami: true // This line!
+};
+```
+
+2. Update the database update query with the new service type to `configureServiceType` function in [src/lib/database/services.ts](src/lib/database/services.ts). This function defines the automatically generated variables (passwords, users, etc.) and it's encryption process (if applicable).
+
+```js
+[...]
+else if (type === 'umami') {
+		const postgresqlUser = cuid();
+		const postgresqlPassword = encrypt(generatePassword());
+		const postgresqlDatabase = 'umami';
+		const hashSalt = encrypt(generatePassword(64));
+		await prisma.service.update({
+			where: { id },
+			data: {
+				type,
+				umami: {
+					create: {
+						postgresqlDatabase,
+						postgresqlPassword,
+						postgresqlUser,
+						hashSalt,
+					}
+				}
+			}
+		});
+	}
+```
+
+3. Add decryption process for configurations and passwords to `getService` function in [src/lib/database/services.ts](src/lib/database/services.ts)
+
+```js
+if (body.umami?.postgresqlPassword)
+	body.umami.postgresqlPassword = decrypt(body.umami.postgresqlPassword);
+
+if (body.umami?.hashSalt) body.umami.hashSalt = decrypt(body.umami.hashSalt);
+```
+
+4. Add service deletion query to `removeService` function in [src/lib/database/services.ts](src/lib/database/services.ts)
+
+### Create API endpoints.
+
+You need to add a new folder under [src/routes/services/[id]](src/routes/services/[id]) with the low-capital name of the service. You need 3 default files in that folder.
+
+#### `index.json.ts`:
+
+It has a POST endpoint that updates the service details in Coolify's database, such as name, url, other configurations, like passwords. It should look something like this:
+
+```js
+import { getUserDetails } from '$lib/common';
+import * as db from '$lib/database';
+import { ErrorHandler } from '$lib/database';
+import type { RequestHandler } from '@sveltejs/kit';
+
+export const post: RequestHandler = async (event) => {
+	const { status, body } = await getUserDetails(event);
+	if (status === 401) return { status, body };
+
+	const { id } = event.params;
+
+	let { name, fqdn } = await event.request.json();
+	if (fqdn) fqdn = fqdn.toLowerCase();
+
+	try {
+		await db.updateService({ id, fqdn, name });
+		return { status: 201 };
+	} catch (error) {
+		return ErrorHandler(error);
+	}
+};
+```
+
+If it's necessary, you can create your own database update function, specifically for the new service.
+
+#### `start.json.ts`
+
+It has a POST endpoint that sets all the required secrets, persistent volumes, `docker-compose.yaml` file and sends a request to the specified docker engine.
+
+You could also define an `HTTP` or `TCP` proxy for every other port that should be proxied to your server. (See `startHttpProxy` and `startTcpProxy` functions in [src/lib/haproxy/index.ts](src/lib/haproxy/index.ts))
+
+#### `stop.json.ts`
+
+It has a POST endpoint that stops the service and all dependent (TCP/HTTP proxies) containers. If publicPort is specified it also needs to cleanup it from the database.
+
+## Frontend
+
+1. You need to add a custom logo at [src/lib/components/svg/services/](src/lib/components/svg/services/) as a svelte component.
+
+   SVG is recommended, but you can use PNG as well. It should have the `isAbsolute` variable with the suitable CSS classes, primarily for sizing and positioning.
+
+2. You need to include it the logo at
+
+- [src/routes/services/index.svelte](src/routes/services/index.svelte) with `isAbsolute` in two places,
+- [src/lib/components/ServiceLinks.svelte](src/lib/components/ServiceLinks.svelte) with `isAbsolute` and a link to the docs/main site of the service
+- [src/routes/services/[id]/configuration/type.svelte](src/routes/services/[id]/configuration/type.svelte) with `isAbsolute`.
+
+3. By default the URL and the name frontend forms are included in [src/routes/services/[id]/\_Services/\_Services.svelte](src/routes/services/[id]/_Services/_Services.svelte).
+
+   If you need to show more details on the frontend, such as users/passwords, you need to add Svelte component to [src/routes/services/[id]/\_Services](src/routes/services/[id]/_Services) with an underscore. For example, see other files in that folder.
+
+   You also need to add the new inputs to the `index.json.ts` file of the specific service, like for MinIO here: [src/routes/services/[id]/minio/index.json.ts](src/routes/services/[id]/minio/index.json.ts)
+
+## 🌐 Translate the project
+
+The project use [sveltekit-i18n](https://github.com/sveltekit-i18n/lib) to translate the project.
+It follows the [ISO 639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) to name languages.
+
+### Installation
+
+You must have gone throw all the [intro](#introduction) steps before you can start translating.
+
+It's only an advice, but I recommend you to use:
+
+- Visual Studio Code
+- [i18n Ally for Visual Studio Code](https://marketplace.visualstudio.com/items?itemName=Lokalise.i18n-ally): ideal to see the progress of the translation.
+- [Svelte for VS Code](https://marketplace.visualstudio.com/items?itemName=svelte.svelte-vscode): to get the syntax color for the project
+
+### Adding a language
+
+If your language doesn't appear in the [locales folder list](src/lib/locales/), follow the step below:
+
+1.  In `src/lib/locales/`, Copy paste `en.json` and rename it with your language (eg: `cz.json`).
+2.  In the [lang.json](src/lib/lang.json) file, add a line after the first bracket (`{`) with `"ISO of your language": "Language",` (eg: `"cz": "Czech",`).
+3.  Have fun translating!

Dockerfile

@@ -0,0 +1,43 @@
+FROM node:18-alpine as build
+WORKDIR /app
+
+RUN apk add --no-cache curl
+RUN curl -sL https://unpkg.com/@pnpm/self-installer | node
+
+COPY . .
+RUN pnpm install
+RUN pnpm build
+
+# Production build
+FROM node:18-alpine
+WORKDIR /app
+ENV NODE_ENV production
+ARG TARGETPLATFORM
+
+ENV PRISMA_QUERY_ENGINE_BINARY=/app/prisma-engines/query-engine \
+  PRISMA_MIGRATION_ENGINE_BINARY=/app/prisma-engines/migration-engine \
+  PRISMA_INTROSPECTION_ENGINE_BINARY=/app/prisma-engines/introspection-engine \
+  PRISMA_FMT_BINARY=/app/prisma-engines/prisma-fmt \
+  PRISMA_CLI_QUERY_ENGINE_TYPE=binary \
+  PRISMA_CLIENT_ENGINE_TYPE=binary
+
+COPY --from=coollabsio/prisma-engine:3.15 /prisma-engines/query-engine /prisma-engines/migration-engine /prisma-engines/introspection-engine /prisma-engines/prisma-fmt /app/prisma-engines/
+
+RUN apk add --no-cache git git-lfs openssh-client curl jq cmake sqlite openssl
+RUN curl -sL https://unpkg.com/@pnpm/self-installer | node
+
+RUN mkdir -p ~/.docker/cli-plugins/
+RUN curl -SL https://cdn.coollabs.io/bin/$TARGETPLATFORM/docker-20.10.9 -o /usr/bin/docker
+RUN curl -SL https://cdn.coollabs.io/bin/$TARGETPLATFORM/docker-compose-linux-2.3.4 -o ~/.docker/cli-plugins/docker-compose
+RUN chmod +x ~/.docker/cli-plugins/docker-compose /usr/bin/docker
+
+COPY --from=build /app/apps/api/build/ .
+COPY --from=build /app/apps/ui/build/ ./public
+COPY --from=build /app/apps/api/prisma/ ./prisma
+COPY --from=build /app/apps/api/package.json .
+COPY --from=build /app/docker-compose.yaml .
+
+RUN pnpm install -p
+
+EXPOSE 3000
+CMD pnpm start

README.md

@@ -1,97 +1,117 @@
-# About
+# Coolify
 
-https://andrasbacsai.com/farewell-netlify-and-heroku-after-3-days-of-coding
+An open-source & self-hostable Heroku / Netlify alternative.
 
-# Features
-- Deploy your Node.js and static sites just by pushing code to git.
-- Hassle-free installation and upgrade process.
-- One-click MongoDB, MySQL, PostgreSQL, CouchDB deployments!
+## Live Demo
 
-# Upcoming features
-- Backups & monitoring.
-- User analytics with privacy in mind.
-- And much more (see [Roadmap](https://github.com/coollabsio/coolify/projects/1)).
+https://demo.coolify.io/
 
+(If it is unresponsive, that means someone overloaded the server. 😄)
 
-# FAQ
-Q: What does Buildpack means?
+## Feedback
 
-A: It defines your application's final form. Static means that it will be hosted as a static site in the end. (see next question below 👇)
+If you have a new service / build pack you would like to add, raise an idea [here](https://feedback.coolify.io/) to get feedback from the community!
 
----
+## How to install
 
-Q: How can I build a static site, like Next.js, Sapper (prerendered), etc ?
+Installation is automated with the following command:
 
-A: Use `static` builder and set your `Build command`.
+```bash
+wget -q https://get.coollabs.io/coolify/install.sh -O install.sh; sudo bash ./install.sh
+```
 
-# Screenshots
+If you would like no questions during installation:
 
-[Login](https://coollabs.io/coolify/login.jpg)
+```bash
+wget -q https://get.coollabs.io/coolify/install.sh -O install.sh; sudo bash ./install.sh -f
+```
 
-[Applications](https://coollabs.io/coolify/applications.jpg)
+For more details goto the [docs](https://docs.coollabs.io/coolify/installation).
 
-[Databases](https://coollabs.io/coolify/databases.jpg)
+## Features
 
-[Configuration](https://coollabs.io/coolify/configuration.jpg)
+ARM support is in beta!
 
-[Settings](https://coollabs.io/coolify/settings.jpg)
+### Git Sources
 
-[Logs](https://coollabs.io/coolify/logs.jpg)
+You can use the following Git Sources to be auto-deployed to your Coolifyt instance! (Self-hosted versions are also supported.)
 
-# Getting Started
+- Github
+- GitLab
+- Bitbucket (WIP)
 
-Automatically: `sh <(curl -fsSL https://get.coollabs.io/install.sh) coolify`
+### Destinations
 
-Manually:
-### Requirements before installation
-- [Docker](https://docs.docker.com/engine/install/) version 20+  
-- Docker in [swarm mode enabled](https://docs.docker.com/engine/reference/commandline/swarm_init/) (should be set manually before installation)
-- A [MongoDB](https://docs.mongodb.com/manual/installation/) instance.
-  - We have a [simple installation](https://github.com/coollabsio/infrastructure/tree/main/mongo) if you need one
-- A configured DNS entry (see `.env.template`)
-- [Github App](https://docs.github.com/en/developers/apps/creating-a-github-app)
+You can deploy your applications to the following destinations:
 
-  - GitHub App name: could be anything weird
-  - Homepage URL: https://yourdomain
+- Local Docker Engine
+- Remote Docker Engine (WIP)
+- Kubernetes (WIP)
 
-  Identifying and authorizing users: 
-  - Callback URL: https://yourdomain/api/v1/login/github/app
-  - Request user authorization (OAuth) during installation -> Check!
+### Applications
 
-  Webhook:
-  - Active -> Check!
-  - Webhook URL: https://yourdomain/api/v1/webhooks/deploy
-  - Webhook Secret: it should be super secret
+These are the predefined build packs, but with the Docker build pack, you can host anything that is hostable with a single Dockerfile.
 
-  Repository permissions:
-  - Contents: Read-only
-  - Metadata: Read-only
-  
-  User permissions: 
-  - Email: Read-only
+- Static sites
+- NodeJS
+- VueJS
+- NuxtJS
+- NextJS
+- React/Preact
+- Gatsby
+- Svelte
+- PHP
+- Laravel
+- Rust
+- Docker
+- Python
+- Deno
 
-  Subscribe to events: 
-  - Push -> Check!
+### Databases
 
-### Installation
-- Clone this repository: `git clone git@github.com:coollabsio/coolify.git`
-- Set `.env` (see `.env.template`)
-- Installation: `bash install.sh all`
+One-click database is ready to be used internally or shared over the internet:
 
-## Updating process
-### Update everything (proxy+coolify)
--  `bash install.sh all`
+- MongoDB
+- MariaDB
+- MySQL
+- PostgreSQL
+- CouchDB
+- Redis
 
-### Update coolify only
--  `bash install.sh coolify`
+### One-click services
 
-### Update proxy only
--  `bash install.sh proxy`
+You can host cool open-source services as well:
+
+- [WordPress](https://docs.coollabs.io/coolify/services/wordpress)
+- [Ghost](https://ghost.org)
+- [Plausible Analytics](https://docs.coollabs.io/coolify/services/plausible-analytics)
+- [NocoDB](https://nocodb.com)
+- [VSCode Server](https://github.com/cdr/code-server)
+- [MinIO](https://min.io)
+- [VaultWarden](https://github.com/dani-garcia/vaultwarden)
+- [LanguageTool](https://languagetool.org)
+- [n8n](https://n8n.io)
+- [Uptime Kuma](https://github.com/louislam/uptime-kuma)
+- [MeiliSearch](https://github.com/meilisearch/meilisearch)
+- [Umami](https://github.com/mikecao/umami)
+- [Fider](https://fider.io)
+- [Hasura](https://hasura.io)
+
+## Migration from v1
+
+A fresh installation is necessary. v2 and v3 are not compatible with v1.
+
+## Support
 
-# Contact
 - Twitter: [@andrasbacsai](https://twitter.com/andrasbacsai)
 - Telegram: [@andrasbacsai](https://t.me/andrasbacsai)
 - Email: [andras@coollabs.io](mailto:andras@coollabs.io)
+- Discord: [Invitation](https://discord.gg/xhBCC7eGKw)
+
+## Contribute
+
+See [our contribution guide](./CONTRIBUTING.md).
+
+## License
 
-# License
 This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. Please see the [LICENSE](/LICENSE) file in our repository for the full text.

api/app.js

@@ -1,27 +0,0 @@
-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'
-  })
-}

api/development/mongodb.js

@@ -1,36 +0,0 @@
-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}`)
-  })
-})

api/libs/applications/build/container.js

@@ -1,34 +0,0 @@
-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' }
-  }
-}

api/libs/applications/cleanup/index.js

@@ -1,41 +0,0 @@
-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 }

api/libs/applications/configuration.js

@@ -1,62 +0,0 @@
-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 }

api/libs/applications/deploy/copyFiles.js

@@ -1,53 +0,0 @@
-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' }
-  }
-}

api/libs/applications/deploy/deploy.js

@@ -1,97 +0,0 @@
-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' }
-  }
-}

api/libs/applications/github/cloneRepository.js

@@ -1,44 +0,0 @@
-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' }
-  }
-}

api/libs/applications/index.js

@@ -1,44 +0,0 @@
-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 }

api/libs/common.js

@@ -1,94 +0,0 @@
-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
-}

api/libs/docker.js

@@ -1,31 +0,0 @@
-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 }

api/libs/logging.js

@@ -1,55 +0,0 @@
-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
-}

api/models/Deployment.js

@@ -1,16 +0,0 @@
-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)

api/models/Logs/Application.js

@@ -1,10 +0,0 @@
-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)

api/models/Logs/Server.js

@@ -1,13 +0,0 @@
-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)

api/models/Settings.js

@@ -1,11 +0,0 @@
-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)

api/models/User.js

@@ -1,12 +0,0 @@
-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)

api/packs/helpers.js

@@ -1,28 +0,0 @@
-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
-}

api/packs/index.js

@@ -1,4 +0,0 @@
-const static = require('./static')
-const nodejs = require('./nodejs')
-
-module.exports = { static, nodejs }

api/packs/nodejs/index.js

@@ -1,32 +0,0 @@
-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)
-}

api/packs/static/index.js

@@ -1,28 +0,0 @@
-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)
-}

api/plugins/authentication.js

@@ -1,21 +0,0 @@
-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()
-})

api/routes/v1/application/check.js

@@ -1,35 +0,0 @@
-
-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' }
-  })
-}

api/routes/v1/application/deploy/index.js

@@ -1,117 +0,0 @@
-
-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 })
-  })
-}

api/routes/v1/application/deploy/logs.js

@@ -1,62 +0,0 @@
-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')
-    }
-  })
-}

api/routes/v1/application/logs.js

@@ -1,10 +0,0 @@
-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 }
-  })
-}

api/routes/v1/application/remove.js

@@ -1,35 +0,0 @@
-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.' })
-    }
-  })
-}

api/routes/v1/config.js

@@ -1,103 +0,0 @@
-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.' };
-  // });
-}

api/routes/v1/dashboard/index.js

@@ -1,55 +0,0 @@
-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
-      }
-    }
-  })
-}

api/routes/v1/databases/index.js

@@ -1,173 +0,0 @@
-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({})
-  })
-}

api/routes/v1/login/github.js

@@ -1,121 +0,0 @@
-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')
-  })
-}

api/routes/v1/settings/index.js

@@ -1,44 +0,0 @@
-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)
-    }
-  })
-}

api/routes/v1/undead.js

@@ -1,5 +0,0 @@
-module.exports = async function (fastify) {
-  fastify.get('/', async (request, reply) => {
-    reply.code(200).send('NO')
-  })
-}

api/routes/v1/upgrade/index.js

@@ -1,12 +0,0 @@
-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' })
-  })
-}

api/routes/v1/verify.js

@@ -1,16 +0,0 @@
-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({})
-  })
-}

api/routes/v1/webhooks/deploy.js

@@ -1,142 +0,0 @@
-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.' })
-  })
-}

api/schema.js

@@ -1,49 +0,0 @@
-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 }

api/server.js

@@ -1,90 +0,0 @@
-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' } })
-  }
-})

apps/api/.eslintignore

@@ -0,0 +1,9 @@
+seed.js
+.DS_Store
+node_modules
+build
+.env
+.env.*
+!.env.example
+dist
+dev.db

apps/api/.eslintrc

@@ -0,0 +1,11 @@
+{
+  "root": true,
+  "parser": "@typescript-eslint/parser",
+  "plugins": ["@typescript-eslint", "prettier"],
+  "extends": [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/eslint-recommended",
+    "plugin:@typescript-eslint/recommended",
+    "prettier"
+  ]
+}

apps/api/.gitignore

@@ -0,0 +1,11 @@
+.DS_Store
+node_modules
+build
+.svelte-kit
+package
+.env
+.env.*
+!.env.example
+dist
+dev.db
+client

apps/api/.prettierrc

@@ -0,0 +1,6 @@
+{
+	"useTabs": true,
+	"singleQuote": true,
+	"trailingComma": "none",
+	"printWidth": 100
+}

apps/api/nodemon.json

@@ -0,0 +1,7 @@
+{
+    "watch": ["src"],
+    "ignore": ["src/**/*.test.ts"],
+    "ext": "ts,mjs,json,graphql",
+    "exec": "rimraf build && esbuild `find src \\( -name '*.ts' \\) | grep -v client/` --platform=node --outdir=build --format=cjs && node build",
+    "legacyWatch": true
+  }

apps/api/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "coolify-api",
+  "description": "Coolify's Fastify API",
+  "license": "AGPL-3.0",
+  "scripts": {
+    "db:push": "prisma db push && prisma generate",
+    "db:seed": "prisma db seed",
+    "db:studio": "prisma studio",
+    "dev": "nodemon",
+    "build": "rimraf build && esbuild `find src \\( -name '*.ts' \\)| grep -v client/` --platform=node --outdir=build --format=cjs",
+    "format": "prettier --write 'src/**/*.{js,ts,json,md}'",
+    "lint": "prettier --check 'src/**/*.{js,ts,json,md}' && eslint --ignore-path .eslintignore .",
+    "start": "NODE_ENV=production npx -y prisma migrate deploy && npx prisma generate && npx prisma db seed && node index.js"
+  },
+  "dependencies": {
+    "@breejs/ts-worker": "2.0.0",
+    "@fastify/autoload": "5.0.0",
+    "@fastify/cookie": "7.0.0",
+    "@fastify/cors": "8.0.0",
+    "@fastify/env": "4.0.0",
+    "@fastify/jwt": "6.2.0",
+    "@fastify/static": "6.4.0",
+    "@iarna/toml": "2.2.5",
+    "@prisma/client": "3.15.2",
+    "axios": "0.27.2",
+    "bcryptjs": "2.4.3",
+    "bree": "9.1.1",
+    "cabin": "9.1.2",
+    "compare-versions": "4.1.3",
+    "cuid": "2.1.8",
+    "dayjs": "1.11.3",
+    "dockerode": "3.3.2",
+    "dotenv-extended": "2.9.0",
+    "fastify": "4.2.0",
+    "fastify-plugin": "3.0.1",
+    "generate-password": "1.7.0",
+    "get-port": "6.1.2",
+    "got": "12.1.0",
+    "is-ip": "4.0.0",
+    "js-yaml": "4.1.0",
+    "jsonwebtoken": "8.5.1",
+    "node-forge": "1.3.1",
+    "node-os-utils": "1.3.7",
+    "p-queue": "7.2.0",
+    "strip-ansi": "7.0.1",
+    "unique-names-generator": "4.7.1"
+  },
+  "devDependencies": {
+    "@types/node": "18.0.3",
+    "@types/node-os-utils": "1.3.0",
+    "@typescript-eslint/eslint-plugin": "5.30.5",
+    "@typescript-eslint/parser": "5.30.5",
+    "esbuild": "0.14.48",
+    "eslint": "8.19.0",
+    "eslint-config-prettier": "8.5.0",
+    "eslint-plugin-prettier": "4.2.1",
+    "nodemon": "2.0.19",
+    "prettier": "2.7.1",
+    "prisma": "3.15.2",
+    "rimraf": "3.0.2",
+    "tsconfig-paths": "4.0.0",
+    "typescript": "4.7.4"
+  },
+  "prisma": {
+    "seed": "node prisma/seed.js"
+  }
+}

apps/api/prisma/migrations/20220131142425_init/migration.sql

@@ -0,0 +1,443 @@
+-- CreateTable
+CREATE TABLE "Setting" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "fqdn" TEXT,
+    "isRegistrationEnabled" BOOLEAN NOT NULL DEFAULT false,
+    "proxyPassword" TEXT NOT NULL,
+    "proxyUser" TEXT NOT NULL,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL
+);
+
+-- CreateTable
+CREATE TABLE "User" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "email" TEXT NOT NULL,
+    "type" TEXT NOT NULL,
+    "password" TEXT,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL
+);
+
+-- CreateTable
+CREATE TABLE "Permission" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "userId" TEXT NOT NULL,
+    "teamId" TEXT NOT NULL,
+    "permission" TEXT NOT NULL,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    CONSTRAINT "Permission_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User" ("id") ON DELETE RESTRICT ON UPDATE CASCADE,
+    CONSTRAINT "Permission_teamId_fkey" FOREIGN KEY ("teamId") REFERENCES "Team" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);
+
+-- CreateTable
+CREATE TABLE "Team" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "name" TEXT,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    "databaseId" TEXT,
+    "serviceId" TEXT,
+    FOREIGN KEY ("databaseId") REFERENCES "Database" ("id") ON DELETE SET NULL ON UPDATE CASCADE,
+    FOREIGN KEY ("serviceId") REFERENCES "Service" ("id") ON DELETE SET NULL ON UPDATE CASCADE
+);
+
+-- CreateTable
+CREATE TABLE "TeamInvitation" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "uid" TEXT NOT NULL,
+    "email" TEXT NOT NULL,
+    "teamId" TEXT NOT NULL,
+    "teamName" TEXT NOT NULL,
+    "permission" TEXT NOT NULL,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+-- CreateTable
+CREATE TABLE "Application" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "name" TEXT NOT NULL,
+    "fqdn" TEXT,
+    "repository" TEXT,
+    "configHash" TEXT,
+    "branch" TEXT,
+    "buildPack" TEXT,
+    "projectId" INTEGER,
+    "port" INTEGER,
+    "installCommand" TEXT,
+    "buildCommand" TEXT,
+    "startCommand" TEXT,
+    "baseDirectory" TEXT,
+    "publishDirectory" TEXT,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    "destinationDockerId" TEXT,
+    "gitSourceId" TEXT,
+    CONSTRAINT "Application_destinationDockerId_fkey" FOREIGN KEY ("destinationDockerId") REFERENCES "DestinationDocker" ("id") ON DELETE SET NULL ON UPDATE CASCADE,
+    CONSTRAINT "Application_gitSourceId_fkey" FOREIGN KEY ("gitSourceId") REFERENCES "GitSource" ("id") ON DELETE SET NULL ON UPDATE CASCADE
+);
+
+-- CreateTable
+CREATE TABLE "ApplicationSettings" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "applicationId" TEXT NOT NULL,
+    "debug" BOOLEAN NOT NULL DEFAULT false,
+    "previews" BOOLEAN NOT NULL DEFAULT false,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    CONSTRAINT "ApplicationSettings_applicationId_fkey" FOREIGN KEY ("applicationId") REFERENCES "Application" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);
+
+-- CreateTable
+CREATE TABLE "Secret" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "name" TEXT NOT NULL,
+    "value" TEXT NOT NULL,
+    "isBuildSecret" BOOLEAN NOT NULL DEFAULT false,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    "applicationId" TEXT NOT NULL,
+    CONSTRAINT "Secret_applicationId_fkey" FOREIGN KEY ("applicationId") REFERENCES "Application" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);
+
+-- CreateTable
+CREATE TABLE "BuildLog" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "applicationId" TEXT,
+    "buildId" TEXT NOT NULL,
+    "line" TEXT NOT NULL,
+    "time" INTEGER NOT NULL
+);
+
+-- CreateTable
+CREATE TABLE "Build" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "type" TEXT NOT NULL,
+    "applicationId" TEXT,
+    "destinationDockerId" TEXT,
+    "gitSourceId" TEXT,
+    "githubAppId" TEXT,
+    "gitlabAppId" TEXT,
+    "commit" TEXT,
+    "status" TEXT DEFAULT 'queued',
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL
+);
+
+-- CreateTable
+CREATE TABLE "DestinationDocker" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "network" TEXT NOT NULL,
+    "name" TEXT NOT NULL,
+    "engine" TEXT NOT NULL,
+    "remoteEngine" BOOLEAN NOT NULL DEFAULT false,
+    "isCoolifyProxyUsed" BOOLEAN DEFAULT false,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL
+);
+
+-- CreateTable
+CREATE TABLE "GitSource" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "name" TEXT NOT NULL,
+    "type" TEXT,
+    "apiUrl" TEXT,
+    "htmlUrl" TEXT,
+    "organization" TEXT,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    "githubAppId" TEXT,
+    "gitlabAppId" TEXT,
+    CONSTRAINT "GitSource_githubAppId_fkey" FOREIGN KEY ("githubAppId") REFERENCES "GithubApp" ("id") ON DELETE SET NULL ON UPDATE CASCADE,
+    CONSTRAINT "GitSource_gitlabAppId_fkey" FOREIGN KEY ("gitlabAppId") REFERENCES "GitlabApp" ("id") ON DELETE SET NULL ON UPDATE CASCADE
+);
+
+-- CreateTable
+CREATE TABLE "GithubApp" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "name" TEXT,
+    "appId" INTEGER,
+    "installationId" INTEGER,
+    "clientId" TEXT,
+    "clientSecret" TEXT,
+    "webhookSecret" TEXT,
+    "privateKey" TEXT,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL
+);
+
+-- CreateTable
+CREATE TABLE "GitlabApp" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "oauthId" INTEGER NOT NULL,
+    "groupName" TEXT,
+    "deployKeyId" INTEGER,
+    "privateSshKey" TEXT,
+    "publicSshKey" TEXT,
+    "webhookToken" TEXT,
+    "appId" TEXT,
+    "appSecret" TEXT,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL
+);
+
+-- CreateTable
+CREATE TABLE "Database" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "name" TEXT NOT NULL,
+    "publicPort" INTEGER,
+    "defaultDatabase" TEXT,
+    "type" TEXT,
+    "version" TEXT,
+    "dbUser" TEXT,
+    "dbUserPassword" TEXT,
+    "rootUser" TEXT,
+    "rootUserPassword" TEXT,
+    "destinationDockerId" TEXT,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    CONSTRAINT "Database_destinationDockerId_fkey" FOREIGN KEY ("destinationDockerId") REFERENCES "DestinationDocker" ("id") ON DELETE SET NULL ON UPDATE CASCADE
+);
+
+-- CreateTable
+CREATE TABLE "DatabaseSettings" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "databaseId" TEXT NOT NULL,
+    "isPublic" BOOLEAN NOT NULL DEFAULT false,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    CONSTRAINT "DatabaseSettings_databaseId_fkey" FOREIGN KEY ("databaseId") REFERENCES "Database" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);
+
+-- CreateTable
+CREATE TABLE "Service" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "name" TEXT NOT NULL,
+    "fqdn" TEXT,
+    "type" TEXT,
+    "version" TEXT,
+    "destinationDockerId" TEXT,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    CONSTRAINT "Service_destinationDockerId_fkey" FOREIGN KEY ("destinationDockerId") REFERENCES "DestinationDocker" ("id") ON DELETE SET NULL ON UPDATE CASCADE
+);
+
+-- CreateTable
+CREATE TABLE "PlausibleAnalytics" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "email" TEXT,
+    "username" TEXT,
+    "password" TEXT NOT NULL,
+    "postgresqlUser" TEXT NOT NULL,
+    "postgresqlPassword" TEXT NOT NULL,
+    "postgresqlDatabase" TEXT NOT NULL,
+    "postgresqlPublicPort" INTEGER,
+    "secretKeyBase" TEXT,
+    "serviceId" TEXT NOT NULL,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    CONSTRAINT "PlausibleAnalytics_serviceId_fkey" FOREIGN KEY ("serviceId") REFERENCES "Service" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);
+
+-- CreateTable
+CREATE TABLE "Minio" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "rootUser" TEXT NOT NULL,
+    "rootUserPassword" TEXT NOT NULL,
+    "publicPort" INTEGER,
+    "serviceId" TEXT NOT NULL,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    CONSTRAINT "Minio_serviceId_fkey" FOREIGN KEY ("serviceId") REFERENCES "Service" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);
+
+-- CreateTable
+CREATE TABLE "Vscodeserver" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "password" TEXT NOT NULL,
+    "serviceId" TEXT NOT NULL,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    CONSTRAINT "Vscodeserver_serviceId_fkey" FOREIGN KEY ("serviceId") REFERENCES "Service" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);
+
+-- CreateTable
+CREATE TABLE "Wordpress" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "extraConfig" TEXT,
+    "tablePrefix" TEXT,
+    "mysqlUser" TEXT NOT NULL,
+    "mysqlPassword" TEXT NOT NULL,
+    "mysqlRootUser" TEXT NOT NULL,
+    "mysqlRootUserPassword" TEXT NOT NULL,
+    "mysqlDatabase" TEXT,
+    "mysqlPublicPort" INTEGER,
+    "serviceId" TEXT NOT NULL,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    CONSTRAINT "Wordpress_serviceId_fkey" FOREIGN KEY ("serviceId") REFERENCES "Service" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);
+
+-- CreateTable
+CREATE TABLE "_TeamToUser" (
+    "A" TEXT NOT NULL,
+    "B" TEXT NOT NULL,
+    FOREIGN KEY ("A") REFERENCES "Team" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
+    FOREIGN KEY ("B") REFERENCES "User" ("id") ON DELETE CASCADE ON UPDATE CASCADE
+);
+
+-- CreateTable
+CREATE TABLE "_ApplicationToTeam" (
+    "A" TEXT NOT NULL,
+    "B" TEXT NOT NULL,
+    FOREIGN KEY ("A") REFERENCES "Application" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
+    FOREIGN KEY ("B") REFERENCES "Team" ("id") ON DELETE CASCADE ON UPDATE CASCADE
+);
+
+-- CreateTable
+CREATE TABLE "_GitSourceToTeam" (
+    "A" TEXT NOT NULL,
+    "B" TEXT NOT NULL,
+    FOREIGN KEY ("A") REFERENCES "GitSource" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
+    FOREIGN KEY ("B") REFERENCES "Team" ("id") ON DELETE CASCADE ON UPDATE CASCADE
+);
+
+-- CreateTable
+CREATE TABLE "_GithubAppToTeam" (
+    "A" TEXT NOT NULL,
+    "B" TEXT NOT NULL,
+    FOREIGN KEY ("A") REFERENCES "GithubApp" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
+    FOREIGN KEY ("B") REFERENCES "Team" ("id") ON DELETE CASCADE ON UPDATE CASCADE
+);
+
+-- CreateTable
+CREATE TABLE "_GitlabAppToTeam" (
+    "A" TEXT NOT NULL,
+    "B" TEXT NOT NULL,
+    FOREIGN KEY ("A") REFERENCES "GitlabApp" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
+    FOREIGN KEY ("B") REFERENCES "Team" ("id") ON DELETE CASCADE ON UPDATE CASCADE
+);
+
+-- CreateTable
+CREATE TABLE "_DestinationDockerToTeam" (
+    "A" TEXT NOT NULL,
+    "B" TEXT NOT NULL,
+    FOREIGN KEY ("A") REFERENCES "DestinationDocker" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
+    FOREIGN KEY ("B") REFERENCES "Team" ("id") ON DELETE CASCADE ON UPDATE CASCADE
+);
+
+-- CreateTable
+CREATE TABLE "_DatabaseToTeam" (
+    "A" TEXT NOT NULL,
+    "B" TEXT NOT NULL,
+    FOREIGN KEY ("A") REFERENCES "Database" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
+    FOREIGN KEY ("B") REFERENCES "Team" ("id") ON DELETE CASCADE ON UPDATE CASCADE
+);
+
+-- CreateTable
+CREATE TABLE "_ServiceToTeam" (
+    "A" TEXT NOT NULL,
+    "B" TEXT NOT NULL,
+    FOREIGN KEY ("A") REFERENCES "Service" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
+    FOREIGN KEY ("B") REFERENCES "Team" ("id") ON DELETE CASCADE ON UPDATE CASCADE
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "Setting_fqdn_key" ON "Setting"("fqdn");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "User_id_key" ON "User"("id");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "User_email_key" ON "User"("email");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "Application_fqdn_key" ON "Application"("fqdn");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "ApplicationSettings_applicationId_key" ON "ApplicationSettings"("applicationId");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "Secret_name_key" ON "Secret"("name");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "DestinationDocker_network_key" ON "DestinationDocker"("network");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "GitSource_githubAppId_key" ON "GitSource"("githubAppId");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "GitSource_gitlabAppId_key" ON "GitSource"("gitlabAppId");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "GithubApp_name_key" ON "GithubApp"("name");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "GitlabApp_oauthId_key" ON "GitlabApp"("oauthId");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "GitlabApp_groupName_key" ON "GitlabApp"("groupName");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "DatabaseSettings_databaseId_key" ON "DatabaseSettings"("databaseId");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "PlausibleAnalytics_serviceId_key" ON "PlausibleAnalytics"("serviceId");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "Minio_serviceId_key" ON "Minio"("serviceId");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "Vscodeserver_serviceId_key" ON "Vscodeserver"("serviceId");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "Wordpress_serviceId_key" ON "Wordpress"("serviceId");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "_TeamToUser_AB_unique" ON "_TeamToUser"("A", "B");
+
+-- CreateIndex
+CREATE INDEX "_TeamToUser_B_index" ON "_TeamToUser"("B");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "_ApplicationToTeam_AB_unique" ON "_ApplicationToTeam"("A", "B");
+
+-- CreateIndex
+CREATE INDEX "_ApplicationToTeam_B_index" ON "_ApplicationToTeam"("B");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "_GitSourceToTeam_AB_unique" ON "_GitSourceToTeam"("A", "B");
+
+-- CreateIndex
+CREATE INDEX "_GitSourceToTeam_B_index" ON "_GitSourceToTeam"("B");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "_GithubAppToTeam_AB_unique" ON "_GithubAppToTeam"("A", "B");
+
+-- CreateIndex
+CREATE INDEX "_GithubAppToTeam_B_index" ON "_GithubAppToTeam"("B");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "_GitlabAppToTeam_AB_unique" ON "_GitlabAppToTeam"("A", "B");
+
+-- CreateIndex
+CREATE INDEX "_GitlabAppToTeam_B_index" ON "_GitlabAppToTeam"("B");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "_DestinationDockerToTeam_AB_unique" ON "_DestinationDockerToTeam"("A", "B");
+
+-- CreateIndex
+CREATE INDEX "_DestinationDockerToTeam_B_index" ON "_DestinationDockerToTeam"("B");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "_DatabaseToTeam_AB_unique" ON "_DatabaseToTeam"("A", "B");
+
+-- CreateIndex
+CREATE INDEX "_DatabaseToTeam_B_index" ON "_DatabaseToTeam"("B");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "_ServiceToTeam_AB_unique" ON "_ServiceToTeam"("A", "B");
+
+-- CreateIndex
+CREATE INDEX "_ServiceToTeam_B_index" ON "_ServiceToTeam"("B");

apps/api/prisma/migrations/20220210104005_redis_aol/migration.sql

@@ -0,0 +1,28 @@
+-- RedefineTables
+PRAGMA foreign_keys=OFF;
+CREATE TABLE "new_Team" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "name" TEXT,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    "databaseId" TEXT,
+    "serviceId" TEXT
+);
+INSERT INTO "new_Team" ("createdAt", "databaseId", "id", "name", "serviceId", "updatedAt") SELECT "createdAt", "databaseId", "id", "name", "serviceId", "updatedAt" FROM "Team";
+DROP TABLE "Team";
+ALTER TABLE "new_Team" RENAME TO "Team";
+CREATE TABLE "new_DatabaseSettings" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "databaseId" TEXT NOT NULL,
+    "isPublic" BOOLEAN NOT NULL DEFAULT false,
+    "appendOnly" BOOLEAN NOT NULL DEFAULT true,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    CONSTRAINT "DatabaseSettings_databaseId_fkey" FOREIGN KEY ("databaseId") REFERENCES "Database" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);
+INSERT INTO "new_DatabaseSettings" ("createdAt", "databaseId", "id", "isPublic", "updatedAt") SELECT "createdAt", "databaseId", "id", "isPublic", "updatedAt" FROM "DatabaseSettings";
+DROP TABLE "DatabaseSettings";
+ALTER TABLE "new_DatabaseSettings" RENAME TO "DatabaseSettings";
+CREATE UNIQUE INDEX "DatabaseSettings_databaseId_key" ON "DatabaseSettings"("databaseId");
+PRAGMA foreign_key_check;
+PRAGMA foreign_keys=ON;

apps/api/prisma/migrations/20220212142309_unique_secret_by_application/migration.sql

@@ -0,0 +1,11 @@
+/*
+  Warnings:
+
+  - A unique constraint covering the columns `[name,applicationId]` on the table `Secret` will be added. If there are existing duplicate values, this will fail.
+
+*/
+-- DropIndex
+DROP INDEX "Secret_name_key";
+
+-- CreateIndex
+CREATE UNIQUE INDEX "Secret_name_applicationId_key" ON "Secret"("name", "applicationId");

apps/api/prisma/migrations/20220217211304_dualcerts/migration.sql

@@ -0,0 +1,47 @@
+-- RedefineTables
+PRAGMA foreign_keys=OFF;
+CREATE TABLE "new_Setting" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "fqdn" TEXT,
+    "isRegistrationEnabled" BOOLEAN NOT NULL DEFAULT false,
+    "dualCerts" BOOLEAN NOT NULL DEFAULT false,
+    "proxyPassword" TEXT NOT NULL,
+    "proxyUser" TEXT NOT NULL,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL
+);
+INSERT INTO "new_Setting" ("createdAt", "fqdn", "id", "isRegistrationEnabled", "proxyPassword", "proxyUser", "updatedAt") SELECT "createdAt", "fqdn", "id", "isRegistrationEnabled", "proxyPassword", "proxyUser", "updatedAt" FROM "Setting";
+DROP TABLE "Setting";
+ALTER TABLE "new_Setting" RENAME TO "Setting";
+CREATE UNIQUE INDEX "Setting_fqdn_key" ON "Setting"("fqdn");
+CREATE TABLE "new_ApplicationSettings" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "applicationId" TEXT NOT NULL,
+    "dualCerts" BOOLEAN NOT NULL DEFAULT false,
+    "debug" BOOLEAN NOT NULL DEFAULT false,
+    "previews" BOOLEAN NOT NULL DEFAULT false,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    CONSTRAINT "ApplicationSettings_applicationId_fkey" FOREIGN KEY ("applicationId") REFERENCES "Application" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);
+INSERT INTO "new_ApplicationSettings" ("applicationId", "createdAt", "debug", "id", "previews", "updatedAt") SELECT "applicationId", "createdAt", "debug", "id", "previews", "updatedAt" FROM "ApplicationSettings";
+DROP TABLE "ApplicationSettings";
+ALTER TABLE "new_ApplicationSettings" RENAME TO "ApplicationSettings";
+CREATE UNIQUE INDEX "ApplicationSettings_applicationId_key" ON "ApplicationSettings"("applicationId");
+CREATE TABLE "new_Service" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "name" TEXT NOT NULL,
+    "fqdn" TEXT,
+    "dualCerts" BOOLEAN NOT NULL DEFAULT false,
+    "type" TEXT,
+    "version" TEXT,
+    "destinationDockerId" TEXT,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    CONSTRAINT "Service_destinationDockerId_fkey" FOREIGN KEY ("destinationDockerId") REFERENCES "DestinationDocker" ("id") ON DELETE SET NULL ON UPDATE CASCADE
+);
+INSERT INTO "new_Service" ("createdAt", "destinationDockerId", "fqdn", "id", "name", "type", "updatedAt", "version") SELECT "createdAt", "destinationDockerId", "fqdn", "id", "name", "type", "updatedAt", "version" FROM "Service";
+DROP TABLE "Service";
+ALTER TABLE "new_Service" RENAME TO "Service";
+PRAGMA foreign_key_check;
+PRAGMA foreign_keys=ON;

apps/api/prisma/migrations/20220219231255_prmr_secrets/migration.sql

@@ -0,0 +1,19 @@
+-- RedefineTables
+PRAGMA foreign_keys=OFF;
+CREATE TABLE "new_Secret" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "name" TEXT NOT NULL,
+    "value" TEXT NOT NULL,
+    "isPRMRSecret" BOOLEAN NOT NULL DEFAULT false,
+    "isBuildSecret" BOOLEAN NOT NULL DEFAULT false,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    "applicationId" TEXT NOT NULL,
+    CONSTRAINT "Secret_applicationId_fkey" FOREIGN KEY ("applicationId") REFERENCES "Application" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);
+INSERT INTO "new_Secret" ("applicationId", "createdAt", "id", "isBuildSecret", "name", "updatedAt", "value") SELECT "applicationId", "createdAt", "id", "isBuildSecret", "name", "updatedAt", "value" FROM "Secret";
+DROP TABLE "Secret";
+ALTER TABLE "new_Secret" RENAME TO "Secret";
+CREATE UNIQUE INDEX "Secret_name_applicationId_isPRMRSecret_key" ON "Secret"("name", "applicationId", "isPRMRSecret");
+PRAGMA foreign_key_check;
+PRAGMA foreign_keys=ON;

apps/api/prisma/migrations/20220220141136_public_portrange/migration.sql

@@ -0,0 +1,20 @@
+-- RedefineTables
+PRAGMA foreign_keys=OFF;
+CREATE TABLE "new_Setting" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "fqdn" TEXT,
+    "isRegistrationEnabled" BOOLEAN NOT NULL DEFAULT false,
+    "dualCerts" BOOLEAN NOT NULL DEFAULT false,
+    "minPort" INTEGER NOT NULL DEFAULT 9000,
+    "maxPort" INTEGER NOT NULL DEFAULT 9100,
+    "proxyPassword" TEXT NOT NULL,
+    "proxyUser" TEXT NOT NULL,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL
+);
+INSERT INTO "new_Setting" ("createdAt", "dualCerts", "fqdn", "id", "isRegistrationEnabled", "proxyPassword", "proxyUser", "updatedAt") SELECT "createdAt", "dualCerts", "fqdn", "id", "isRegistrationEnabled", "proxyPassword", "proxyUser", "updatedAt" FROM "Setting";
+DROP TABLE "Setting";
+ALTER TABLE "new_Setting" RENAME TO "Setting";
+CREATE UNIQUE INDEX "Setting_fqdn_key" ON "Setting"("fqdn");
+PRAGMA foreign_key_check;
+PRAGMA foreign_keys=ON;

apps/api/prisma/migrations/20220301101928_proxyhash/migration.sql

@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "Setting" ADD COLUMN "proxyHash" TEXT;

apps/api/prisma/migrations/20220304141408_service_secrets/migration.sql

@@ -0,0 +1,13 @@
+-- CreateTable
+CREATE TABLE "ServiceSecret" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "name" TEXT NOT NULL,
+    "value" TEXT NOT NULL,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    "serviceId" TEXT NOT NULL,
+    CONSTRAINT "ServiceSecret_serviceId_fkey" FOREIGN KEY ("serviceId") REFERENCES "Service" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "ServiceSecret_name_serviceId_key" ON "ServiceSecret"("name", "serviceId");

apps/api/prisma/migrations/20220311213422_autodeploy/migration.sql

@@ -0,0 +1,19 @@
+-- RedefineTables
+PRAGMA foreign_keys=OFF;
+CREATE TABLE "new_ApplicationSettings" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "applicationId" TEXT NOT NULL,
+    "dualCerts" BOOLEAN NOT NULL DEFAULT false,
+    "debug" BOOLEAN NOT NULL DEFAULT false,
+    "previews" BOOLEAN NOT NULL DEFAULT false,
+    "autodeploy" BOOLEAN NOT NULL DEFAULT true,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    CONSTRAINT "ApplicationSettings_applicationId_fkey" FOREIGN KEY ("applicationId") REFERENCES "Application" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);
+INSERT INTO "new_ApplicationSettings" ("applicationId", "createdAt", "debug", "dualCerts", "id", "previews", "updatedAt") SELECT "applicationId", "createdAt", "debug", "dualCerts", "id", "previews", "updatedAt" FROM "ApplicationSettings";
+DROP TABLE "ApplicationSettings";
+ALTER TABLE "new_ApplicationSettings" RENAME TO "ApplicationSettings";
+CREATE UNIQUE INDEX "ApplicationSettings_applicationId_key" ON "ApplicationSettings"("applicationId");
+PRAGMA foreign_key_check;
+PRAGMA foreign_keys=ON;

apps/api/prisma/migrations/20220320141424_phpmodules/migration.sql

@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "Application" ADD COLUMN "phpModules" TEXT;

apps/api/prisma/migrations/20220322135800_persistent_storage/migration.sql

@@ -0,0 +1,18 @@
+-- CreateTable
+CREATE TABLE "ApplicationPersistentStorage" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "applicationId" TEXT NOT NULL,
+    "path" TEXT NOT NULL,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    CONSTRAINT "ApplicationPersistentStorage_applicationId_fkey" FOREIGN KEY ("applicationId") REFERENCES "Application" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "ApplicationPersistentStorage_applicationId_key" ON "ApplicationPersistentStorage"("applicationId");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "ApplicationPersistentStorage_path_key" ON "ApplicationPersistentStorage"("path");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "ApplicationPersistentStorage_applicationId_path_key" ON "ApplicationPersistentStorage"("applicationId", "path");

apps/api/prisma/migrations/20220327180323_ghost/migration.sql

@@ -0,0 +1,19 @@
+-- CreateTable
+CREATE TABLE "Ghost" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "defaultEmail" TEXT NOT NULL,
+    "defaultPassword" TEXT NOT NULL,
+    "mariadbUser" TEXT NOT NULL,
+    "mariadbPassword" TEXT NOT NULL,
+    "mariadbRootUser" TEXT NOT NULL,
+    "mariadbRootUserPassword" TEXT NOT NULL,
+    "mariadbDatabase" TEXT,
+    "mariadbPublicPort" INTEGER,
+    "serviceId" TEXT NOT NULL,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    CONSTRAINT "Ghost_serviceId_fkey" FOREIGN KEY ("serviceId") REFERENCES "Service" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "Ghost_serviceId_key" ON "Ghost"("serviceId");

apps/api/prisma/migrations/20220402135305_python/migration.sql

@@ -0,0 +1,4 @@
+-- AlterTable
+ALTER TABLE "Application" ADD COLUMN "pythonModule" TEXT;
+ALTER TABLE "Application" ADD COLUMN "pythonVariable" TEXT;
+ALTER TABLE "Application" ADD COLUMN "pythonWSGI" TEXT;

apps/api/prisma/migrations/20220402210645_meilisearch/migration.sql

@@ -0,0 +1,12 @@
+-- CreateTable
+CREATE TABLE "MeiliSearch" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "masterKey" TEXT NOT NULL,
+    "serviceId" TEXT NOT NULL,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    CONSTRAINT "MeiliSearch_serviceId_fkey" FOREIGN KEY ("serviceId") REFERENCES "Service" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "MeiliSearch_serviceId_key" ON "MeiliSearch"("serviceId");

apps/api/prisma/migrations/20220405151428_wordpress_sftp/migration.sql

@@ -0,0 +1,29 @@
+-- RedefineTables
+PRAGMA foreign_keys=OFF;
+CREATE TABLE "new_Wordpress" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "extraConfig" TEXT,
+    "tablePrefix" TEXT,
+    "mysqlUser" TEXT NOT NULL,
+    "mysqlPassword" TEXT NOT NULL,
+    "mysqlRootUser" TEXT NOT NULL,
+    "mysqlRootUserPassword" TEXT NOT NULL,
+    "mysqlDatabase" TEXT,
+    "mysqlPublicPort" INTEGER,
+    "ftpEnabled" BOOLEAN NOT NULL DEFAULT false,
+    "ftpUser" TEXT,
+    "ftpPassword" TEXT,
+    "ftpPublicPort" INTEGER,
+    "ftpHostKey" TEXT,
+    "ftpHostKeyPrivate" TEXT,
+    "serviceId" TEXT NOT NULL,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    CONSTRAINT "Wordpress_serviceId_fkey" FOREIGN KEY ("serviceId") REFERENCES "Service" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);
+INSERT INTO "new_Wordpress" ("createdAt", "extraConfig", "id", "mysqlDatabase", "mysqlPassword", "mysqlPublicPort", "mysqlRootUser", "mysqlRootUserPassword", "mysqlUser", "serviceId", "tablePrefix", "updatedAt") SELECT "createdAt", "extraConfig", "id", "mysqlDatabase", "mysqlPassword", "mysqlPublicPort", "mysqlRootUser", "mysqlRootUserPassword", "mysqlUser", "serviceId", "tablePrefix", "updatedAt" FROM "Wordpress";
+DROP TABLE "Wordpress";
+ALTER TABLE "new_Wordpress" RENAME TO "Wordpress";
+CREATE UNIQUE INDEX "Wordpress_serviceId_key" ON "Wordpress"("serviceId");
+PRAGMA foreign_key_check;
+PRAGMA foreign_keys=ON;

apps/api/prisma/migrations/20220407220809_unique_storage_fix/migration.sql

@@ -0,0 +1,5 @@
+-- DropIndex
+DROP INDEX "ApplicationPersistentStorage_path_key";
+
+-- DropIndex
+DROP INDEX "ApplicationPersistentStorage_applicationId_key";

apps/api/prisma/migrations/20220408070805_added_expose_port/migration.sql

@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "Application" ADD COLUMN "exposePort" INTEGER;

apps/api/prisma/migrations/20220418214843_persistent_storage_services/migration.sql

@@ -0,0 +1,12 @@
+-- CreateTable
+CREATE TABLE "ServicePersistentStorage" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "serviceId" TEXT NOT NULL,
+    "path" TEXT NOT NULL,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    CONSTRAINT "ServicePersistentStorage_serviceId_fkey" FOREIGN KEY ("serviceId") REFERENCES "Service" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "ServicePersistentStorage_serviceId_path_key" ON "ServicePersistentStorage"("serviceId", "path");

apps/api/prisma/migrations/20220419203408_multiply_dockerfile_locations/migration.sql

@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "Application" ADD COLUMN "dockerFileLocation" TEXT;

apps/api/prisma/migrations/20220420202031_deno_configurations/migration.sql

@@ -0,0 +1,3 @@
+-- AlterTable
+ALTER TABLE "Application" ADD COLUMN "denoMainFile" TEXT;
+ALTER TABLE "Application" ADD COLUMN "denoOptions" TEXT;

apps/api/prisma/migrations/20220420210057_branch_for_builds/migration.sql

@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "Build" ADD COLUMN "branch" TEXT;

apps/api/prisma/migrations/20220425071132_umami/migration.sql

@@ -0,0 +1,17 @@
+-- CreateTable
+CREATE TABLE "Umami" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "serviceId" TEXT NOT NULL,
+    "postgresqlUser" TEXT NOT NULL,
+    "postgresqlPassword" TEXT NOT NULL,
+    "postgresqlDatabase" TEXT NOT NULL,
+    "postgresqlPublicPort" INTEGER,
+    "umamiAdminPassword" TEXT NOT NULL,
+    "hashSalt" TEXT NOT NULL,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    CONSTRAINT "Umami_serviceId_fkey" FOREIGN KEY ("serviceId") REFERENCES "Service" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "Umami_serviceId_key" ON "Umami"("serviceId");

apps/api/prisma/migrations/20220425075326_auto_update_coolify/migration.sql

@@ -0,0 +1,22 @@
+-- RedefineTables
+PRAGMA foreign_keys=OFF;
+CREATE TABLE "new_Setting" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "fqdn" TEXT,
+    "isRegistrationEnabled" BOOLEAN NOT NULL DEFAULT false,
+    "dualCerts" BOOLEAN NOT NULL DEFAULT false,
+    "minPort" INTEGER NOT NULL DEFAULT 9000,
+    "maxPort" INTEGER NOT NULL DEFAULT 9100,
+    "proxyPassword" TEXT NOT NULL,
+    "proxyUser" TEXT NOT NULL,
+    "proxyHash" TEXT,
+    "isAutoUpdateEnabled" BOOLEAN NOT NULL DEFAULT false,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL
+);
+INSERT INTO "new_Setting" ("createdAt", "dualCerts", "fqdn", "id", "isRegistrationEnabled", "maxPort", "minPort", "proxyHash", "proxyPassword", "proxyUser", "updatedAt") SELECT "createdAt", "dualCerts", "fqdn", "id", "isRegistrationEnabled", "maxPort", "minPort", "proxyHash", "proxyPassword", "proxyUser", "updatedAt" FROM "Setting";
+DROP TABLE "Setting";
+ALTER TABLE "new_Setting" RENAME TO "Setting";
+CREATE UNIQUE INDEX "Setting_fqdn_key" ON "Setting"("fqdn");
+PRAGMA foreign_key_check;
+PRAGMA foreign_keys=ON;

apps/api/prisma/migrations/20220426125053_select_base_image/migration.sql

@@ -0,0 +1,3 @@
+-- AlterTable
+ALTER TABLE "Application" ADD COLUMN "baseBuildImage" TEXT;
+ALTER TABLE "Application" ADD COLUMN "baseImage" TEXT;

apps/api/prisma/migrations/20220427133656_hasura/migration.sql

@@ -0,0 +1,16 @@
+-- CreateTable
+CREATE TABLE "Hasura" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "serviceId" TEXT NOT NULL,
+    "postgresqlUser" TEXT NOT NULL,
+    "postgresqlPassword" TEXT NOT NULL,
+    "postgresqlDatabase" TEXT NOT NULL,
+    "postgresqlPublicPort" INTEGER,
+    "graphQLAdminPassword" TEXT NOT NULL,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    CONSTRAINT "Hasura_serviceId_fkey" FOREIGN KEY ("serviceId") REFERENCES "Service" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "Hasura_serviceId_key" ON "Hasura"("serviceId");

apps/api/prisma/migrations/20220429202516_fider/migration.sql

@@ -0,0 +1,25 @@
+-- CreateTable
+CREATE TABLE "Fider" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "serviceId" TEXT NOT NULL,
+    "postgresqlUser" TEXT NOT NULL,
+    "postgresqlPassword" TEXT NOT NULL,
+    "postgresqlDatabase" TEXT NOT NULL,
+    "postgresqlPublicPort" INTEGER,
+    "jwtSecret" TEXT NOT NULL,
+    "emailNoreply" TEXT,
+    "emailMailgunApiKey" TEXT,
+    "emailMailgunDomain" TEXT,
+    "emailMailgunRegion" TEXT,
+    "emailSmtpHost" TEXT,
+    "emailSmtpPort" INTEGER,
+    "emailSmtpUser" TEXT,
+    "emailSmtpPassword" TEXT,
+    "emailSmtpEnableStartTls" BOOLEAN NOT NULL DEFAULT false,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    CONSTRAINT "Fider_serviceId_fkey" FOREIGN KEY ("serviceId") REFERENCES "Service" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "Fider_serviceId_key" ON "Fider"("serviceId");

apps/api/prisma/migrations/20220429214112_fider_correction/migration.sql

@@ -0,0 +1,29 @@
+-- RedefineTables
+PRAGMA foreign_keys=OFF;
+CREATE TABLE "new_Fider" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "serviceId" TEXT NOT NULL,
+    "postgresqlUser" TEXT NOT NULL,
+    "postgresqlPassword" TEXT NOT NULL,
+    "postgresqlDatabase" TEXT NOT NULL,
+    "postgresqlPublicPort" INTEGER,
+    "jwtSecret" TEXT NOT NULL,
+    "emailNoreply" TEXT,
+    "emailMailgunApiKey" TEXT,
+    "emailMailgunDomain" TEXT,
+    "emailMailgunRegion" TEXT NOT NULL DEFAULT 'EU',
+    "emailSmtpHost" TEXT,
+    "emailSmtpPort" INTEGER,
+    "emailSmtpUser" TEXT,
+    "emailSmtpPassword" TEXT,
+    "emailSmtpEnableStartTls" BOOLEAN NOT NULL DEFAULT false,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    CONSTRAINT "Fider_serviceId_fkey" FOREIGN KEY ("serviceId") REFERENCES "Service" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);
+INSERT INTO "new_Fider" ("createdAt", "emailMailgunApiKey", "emailMailgunDomain", "emailMailgunRegion", "emailNoreply", "emailSmtpEnableStartTls", "emailSmtpHost", "emailSmtpPassword", "emailSmtpPort", "emailSmtpUser", "id", "jwtSecret", "postgresqlDatabase", "postgresqlPassword", "postgresqlPublicPort", "postgresqlUser", "serviceId", "updatedAt") SELECT "createdAt", "emailMailgunApiKey", "emailMailgunDomain", coalesce("emailMailgunRegion", 'EU') AS "emailMailgunRegion", "emailNoreply", "emailSmtpEnableStartTls", "emailSmtpHost", "emailSmtpPassword", "emailSmtpPort", "emailSmtpUser", "id", "jwtSecret", "postgresqlDatabase", "postgresqlPassword", "postgresqlPublicPort", "postgresqlUser", "serviceId", "updatedAt" FROM "Fider";
+DROP TABLE "Fider";
+ALTER TABLE "new_Fider" RENAME TO "Fider";
+CREATE UNIQUE INDEX "Fider_serviceId_key" ON "Fider"("serviceId");
+PRAGMA foreign_key_check;
+PRAGMA foreign_keys=ON;

apps/api/prisma/migrations/20220430111953_ssl_dns_check_settings/migration.sql

@@ -0,0 +1,23 @@
+-- RedefineTables
+PRAGMA foreign_keys=OFF;
+CREATE TABLE "new_Setting" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "fqdn" TEXT,
+    "isRegistrationEnabled" BOOLEAN NOT NULL DEFAULT false,
+    "dualCerts" BOOLEAN NOT NULL DEFAULT false,
+    "minPort" INTEGER NOT NULL DEFAULT 9000,
+    "maxPort" INTEGER NOT NULL DEFAULT 9100,
+    "proxyPassword" TEXT NOT NULL,
+    "proxyUser" TEXT NOT NULL,
+    "proxyHash" TEXT,
+    "isAutoUpdateEnabled" BOOLEAN NOT NULL DEFAULT false,
+    "isDNSCheckEnabled" BOOLEAN NOT NULL DEFAULT true,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL
+);
+INSERT INTO "new_Setting" ("createdAt", "dualCerts", "fqdn", "id", "isAutoUpdateEnabled", "isRegistrationEnabled", "maxPort", "minPort", "proxyHash", "proxyPassword", "proxyUser", "updatedAt") SELECT "createdAt", "dualCerts", "fqdn", "id", "isAutoUpdateEnabled", "isRegistrationEnabled", "maxPort", "minPort", "proxyHash", "proxyPassword", "proxyUser", "updatedAt" FROM "Setting";
+DROP TABLE "Setting";
+ALTER TABLE "new_Setting" RENAME TO "Setting";
+CREATE UNIQUE INDEX "Setting_fqdn_key" ON "Setting"("fqdn");
+PRAGMA foreign_key_check;
+PRAGMA foreign_keys=ON;

apps/api/prisma/migrations/20220430124553_expose_port_for_services/migration.sql

@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "Service" ADD COLUMN "exposePort" INTEGER;

apps/api/prisma/migrations/20220509130501_custom_plausible_script/migration.sql

@@ -0,0 +1,24 @@
+-- RedefineTables
+PRAGMA foreign_keys=OFF;
+CREATE TABLE "new_PlausibleAnalytics" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "email" TEXT,
+    "username" TEXT,
+    "password" TEXT NOT NULL,
+    "postgresqlUser" TEXT NOT NULL,
+    "postgresqlPassword" TEXT NOT NULL,
+    "postgresqlDatabase" TEXT NOT NULL,
+    "postgresqlPublicPort" INTEGER,
+    "secretKeyBase" TEXT,
+    "scriptName" TEXT NOT NULL DEFAULT 'plausible.js',
+    "serviceId" TEXT NOT NULL,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    CONSTRAINT "PlausibleAnalytics_serviceId_fkey" FOREIGN KEY ("serviceId") REFERENCES "Service" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);
+INSERT INTO "new_PlausibleAnalytics" ("createdAt", "email", "id", "password", "postgresqlDatabase", "postgresqlPassword", "postgresqlPublicPort", "postgresqlUser", "secretKeyBase", "serviceId", "updatedAt", "username") SELECT "createdAt", "email", "id", "password", "postgresqlDatabase", "postgresqlPassword", "postgresqlPublicPort", "postgresqlUser", "secretKeyBase", "serviceId", "updatedAt", "username" FROM "PlausibleAnalytics";
+DROP TABLE "PlausibleAnalytics";
+ALTER TABLE "new_PlausibleAnalytics" RENAME TO "PlausibleAnalytics";
+CREATE UNIQUE INDEX "PlausibleAnalytics_serviceId_key" ON "PlausibleAnalytics"("serviceId");
+PRAGMA foreign_key_check;
+PRAGMA foreign_keys=ON;

apps/api/prisma/migrations/20220510081125_custom_wordpress_db/migration.sql

@@ -0,0 +1,32 @@
+-- RedefineTables
+PRAGMA foreign_keys=OFF;
+CREATE TABLE "new_Wordpress" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "extraConfig" TEXT,
+    "tablePrefix" TEXT,
+    "ownMysql" BOOLEAN NOT NULL DEFAULT false,
+    "mysqlHost" TEXT,
+    "mysqlPort" INTEGER,
+    "mysqlUser" TEXT NOT NULL,
+    "mysqlPassword" TEXT NOT NULL,
+    "mysqlRootUser" TEXT NOT NULL,
+    "mysqlRootUserPassword" TEXT NOT NULL,
+    "mysqlDatabase" TEXT,
+    "mysqlPublicPort" INTEGER,
+    "ftpEnabled" BOOLEAN NOT NULL DEFAULT false,
+    "ftpUser" TEXT,
+    "ftpPassword" TEXT,
+    "ftpPublicPort" INTEGER,
+    "ftpHostKey" TEXT,
+    "ftpHostKeyPrivate" TEXT,
+    "serviceId" TEXT NOT NULL,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL,
+    CONSTRAINT "Wordpress_serviceId_fkey" FOREIGN KEY ("serviceId") REFERENCES "Service" ("id") ON DELETE RESTRICT ON UPDATE CASCADE
+);
+INSERT INTO "new_Wordpress" ("createdAt", "extraConfig", "ftpEnabled", "ftpHostKey", "ftpHostKeyPrivate", "ftpPassword", "ftpPublicPort", "ftpUser", "id", "mysqlDatabase", "mysqlPassword", "mysqlPublicPort", "mysqlRootUser", "mysqlRootUserPassword", "mysqlUser", "serviceId", "tablePrefix", "updatedAt") SELECT "createdAt", "extraConfig", "ftpEnabled", "ftpHostKey", "ftpHostKeyPrivate", "ftpPassword", "ftpPublicPort", "ftpUser", "id", "mysqlDatabase", "mysqlPassword", "mysqlPublicPort", "mysqlRootUser", "mysqlRootUserPassword", "mysqlUser", "serviceId", "tablePrefix", "updatedAt" FROM "Wordpress";
+DROP TABLE "Wordpress";
+ALTER TABLE "new_Wordpress" RENAME TO "Wordpress";
+CREATE UNIQUE INDEX "Wordpress_serviceId_key" ON "Wordpress"("serviceId");
+PRAGMA foreign_key_check;
+PRAGMA foreign_keys=ON;

apps/api/prisma/migrations/20220517081328_traefik/migration.sql

@@ -0,0 +1,24 @@
+-- RedefineTables
+PRAGMA foreign_keys=OFF;
+CREATE TABLE "new_Setting" (
+    "id" TEXT NOT NULL PRIMARY KEY,
+    "fqdn" TEXT,
+    "isRegistrationEnabled" BOOLEAN NOT NULL DEFAULT false,
+    "dualCerts" BOOLEAN NOT NULL DEFAULT false,
+    "minPort" INTEGER NOT NULL DEFAULT 9000,
+    "maxPort" INTEGER NOT NULL DEFAULT 9100,
+    "proxyPassword" TEXT NOT NULL,
+    "proxyUser" TEXT NOT NULL,
+    "proxyHash" TEXT,
+    "isAutoUpdateEnabled" BOOLEAN NOT NULL DEFAULT false,
+    "isDNSCheckEnabled" BOOLEAN NOT NULL DEFAULT true,
+    "isTraefikUsed" BOOLEAN NOT NULL DEFAULT true,
+    "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" DATETIME NOT NULL
+);
+INSERT INTO "new_Setting" ("createdAt", "dualCerts", "fqdn", "id", "isAutoUpdateEnabled", "isDNSCheckEnabled", "isRegistrationEnabled", "maxPort", "minPort", "proxyHash", "proxyPassword", "proxyUser", "updatedAt") SELECT "createdAt", "dualCerts", "fqdn", "id", "isAutoUpdateEnabled", "isDNSCheckEnabled", "isRegistrationEnabled", "maxPort", "minPort", "proxyHash", "proxyPassword", "proxyUser", "updatedAt" FROM "Setting";
+DROP TABLE "Setting";
+ALTER TABLE "new_Setting" RENAME TO "Setting";
+CREATE UNIQUE INDEX "Setting_fqdn_key" ON "Setting"("fqdn");
+PRAGMA foreign_key_check;
+PRAGMA foreign_keys=ON;

apps/api/prisma/migrations/20220519095648_minio_apifqdn/migration.sql

@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "Minio" ADD COLUMN "apiFqdn" TEXT;

apps/api/prisma/migrations/migration_lock.toml

@@ -0,0 +1,3 @@
+# Please do not edit this file manually
+# It should be added in your version-control system (i.e. Git)
+provider = "sqlite"

apps/api/prisma/schema.prisma

@@ -0,0 +1,451 @@
+generator client {
+  provider      = "prisma-client-js"
+  binaryTargets = ["native", "linux-musl"]
+}
+
+datasource db {
+  provider = "sqlite"
+  url      = env("COOLIFY_DATABASE_URL")
+}
+
+model Setting {
+  id                    String   @id @default(cuid())
+  fqdn                  String?  @unique
+  isRegistrationEnabled Boolean  @default(false)
+  dualCerts             Boolean  @default(false)
+  minPort               Int      @default(9000)
+  maxPort               Int      @default(9100)
+  proxyPassword         String
+  proxyUser             String
+  proxyHash             String?
+  isAutoUpdateEnabled   Boolean  @default(false)
+  isDNSCheckEnabled     Boolean  @default(true)
+  isTraefikUsed         Boolean  @default(true)
+  createdAt             DateTime @default(now())
+  updatedAt             DateTime @updatedAt
+}
+
+model User {
+  id         String       @id @unique @default(cuid())
+  email      String       @unique
+  type       String
+  password   String?
+  teams      Team[]
+  permission Permission[]
+  createdAt  DateTime     @default(now())
+  updatedAt  DateTime     @updatedAt
+}
+
+model Permission {
+  id         String   @id @default(cuid())
+  user       User     @relation(fields: [userId], references: [id])
+  userId     String
+  team       Team     @relation(fields: [teamId], references: [id])
+  teamId     String
+  permission String
+  createdAt  DateTime @default(now())
+  updatedAt  DateTime @updatedAt
+}
+
+model Team {
+  id                String              @id @default(cuid())
+  users             User[]
+  name              String?
+  applications      Application[]
+  gitSources        GitSource[]
+  gitHubApps        GithubApp[]
+  gitLabApps        GitlabApp[]
+  destinationDocker DestinationDocker[]
+  permissions       Permission[]
+  createdAt         DateTime            @default(now())
+  updatedAt         DateTime            @updatedAt
+  database          Database[]          @relation(references: [id])
+  databaseId        String?
+  service           Service[]           @relation(references: [id])
+  serviceId         String?
+}
+
+model TeamInvitation {
+  id         String   @id @default(cuid())
+  uid        String
+  email      String
+  teamId     String
+  teamName   String
+  permission String
+  createdAt  DateTime @default(now())
+}
+
+model Application {
+  id                  String                         @id @default(cuid())
+  name                String
+  fqdn                String?                        @unique
+  repository          String?
+  configHash          String?
+  branch              String?
+  buildPack           String?
+  projectId           Int?
+  port                Int?
+  exposePort          Int?
+  installCommand      String?
+  buildCommand        String?
+  startCommand        String?
+  baseDirectory       String?
+  publishDirectory    String?
+  phpModules          String?
+  pythonWSGI          String?
+  pythonModule        String?
+  pythonVariable      String?
+  dockerFileLocation  String?
+  denoMainFile        String?
+  denoOptions         String?
+  createdAt           DateTime                       @default(now())
+  updatedAt           DateTime                       @updatedAt
+  settings            ApplicationSettings?
+  teams               Team[]
+  destinationDockerId String?
+  destinationDocker   DestinationDocker?             @relation(fields: [destinationDockerId], references: [id])
+  gitSourceId         String?
+  gitSource           GitSource?                     @relation(fields: [gitSourceId], references: [id])
+  secrets             Secret[]
+  persistentStorage   ApplicationPersistentStorage[]
+  baseImage           String?
+  baseBuildImage      String?
+}
+
+model ApplicationSettings {
+  id            String      @id @default(cuid())
+  application   Application @relation(fields: [applicationId], references: [id])
+  applicationId String      @unique
+  dualCerts     Boolean     @default(false)
+  debug         Boolean     @default(false)
+  previews      Boolean     @default(false)
+  autodeploy    Boolean     @default(true)
+  createdAt     DateTime    @default(now())
+  updatedAt     DateTime    @updatedAt
+}
+
+model ApplicationPersistentStorage {
+  id            String      @id @default(cuid())
+  application   Application @relation(fields: [applicationId], references: [id])
+  applicationId String
+  path          String
+  createdAt     DateTime    @default(now())
+  updatedAt     DateTime    @updatedAt
+
+  @@unique([applicationId, path])
+}
+
+model ServicePersistentStorage {
+  id        String   @id @default(cuid())
+  service   Service  @relation(fields: [serviceId], references: [id])
+  serviceId String
+  path      String
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  @@unique([serviceId, path])
+}
+
+model Secret {
+  id            String      @id @default(cuid())
+  name          String
+  value         String
+  isPRMRSecret  Boolean     @default(false)
+  isBuildSecret Boolean     @default(false)
+  createdAt     DateTime    @default(now())
+  updatedAt     DateTime    @updatedAt
+  application   Application @relation(fields: [applicationId], references: [id])
+  applicationId String
+
+  @@unique([name, applicationId, isPRMRSecret])
+}
+
+model ServiceSecret {
+  id        String   @id @default(cuid())
+  name      String
+  value     String
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+  service   Service  @relation(fields: [serviceId], references: [id])
+  serviceId String
+
+  @@unique([name, serviceId])
+}
+
+model BuildLog {
+  id            String  @id @default(cuid())
+  applicationId String?
+  buildId       String
+  line          String
+  time          Int
+}
+
+model Build {
+  id                  String   @id @default(cuid())
+  type                String
+  applicationId       String?
+  destinationDockerId String?
+  gitSourceId         String?
+  githubAppId         String?
+  gitlabAppId         String?
+  commit              String?
+  branch              String?
+  status              String?  @default("queued")
+  createdAt           DateTime @default(now())
+  updatedAt           DateTime @updatedAt
+}
+
+model DestinationDocker {
+  id                 String        @id @default(cuid())
+  network            String        @unique
+  name               String
+  engine             String
+  remoteEngine       Boolean       @default(false)
+  isCoolifyProxyUsed Boolean?      @default(false)
+  teams              Team[]
+  application        Application[]
+  createdAt          DateTime      @default(now())
+  updatedAt          DateTime      @updatedAt
+  database           Database[]
+  service            Service[]
+}
+
+model GitSource {
+  id           String        @id @default(cuid())
+  name         String
+  teams        Team[]
+  type         String?
+  apiUrl       String?
+  htmlUrl      String?
+  organization String?
+  createdAt    DateTime      @default(now())
+  updatedAt    DateTime      @updatedAt
+  githubAppId  String?       @unique
+  githubApp    GithubApp?    @relation(fields: [githubAppId], references: [id])
+  application  Application[]
+  gitlabAppId  String?       @unique
+  gitlabApp    GitlabApp?    @relation(fields: [gitlabAppId], references: [id])
+}
+
+model GithubApp {
+  id             String     @id @default(cuid())
+  name           String?    @unique
+  teams          Team[]
+  appId          Int?
+  installationId Int?
+  clientId       String?
+  clientSecret   String?
+  webhookSecret  String?
+  privateKey     String?
+  createdAt      DateTime   @default(now())
+  updatedAt      DateTime   @updatedAt
+  gitSource      GitSource?
+}
+
+model GitlabApp {
+  id            String     @id @default(cuid())
+  oauthId       Int        @unique
+  groupName     String?    @unique
+  teams         Team[]
+  deployKeyId   Int?
+  privateSshKey String?
+  publicSshKey  String?
+  webhookToken  String?
+  appId         String?
+  appSecret     String?
+  createdAt     DateTime   @default(now())
+  updatedAt     DateTime   @updatedAt
+  gitSource     GitSource?
+}
+
+model Database {
+  id                  String             @id @default(cuid())
+  name                String
+  publicPort          Int?
+  defaultDatabase     String?
+  type                String?
+  version             String?
+  dbUser              String?
+  dbUserPassword      String?
+  rootUser            String?
+  rootUserPassword    String?
+  settings            DatabaseSettings?
+  destinationDocker   DestinationDocker? @relation(fields: [destinationDockerId], references: [id])
+  destinationDockerId String?
+  teams               Team[]
+  createdAt           DateTime           @default(now())
+  updatedAt           DateTime           @updatedAt
+}
+
+model DatabaseSettings {
+  id         String   @id @default(cuid())
+  database   Database @relation(fields: [databaseId], references: [id])
+  databaseId String   @unique
+  isPublic   Boolean  @default(false)
+  appendOnly Boolean  @default(true)
+  createdAt  DateTime @default(now())
+  updatedAt  DateTime @updatedAt
+}
+
+model Service {
+  id                  String                     @id @default(cuid())
+  name                String
+  fqdn                String?
+  exposePort          Int?
+  dualCerts           Boolean                    @default(false)
+  type                String?
+  version             String?
+  teams               Team[]
+  destinationDockerId String?
+  destinationDocker   DestinationDocker?         @relation(fields: [destinationDockerId], references: [id])
+  createdAt           DateTime                   @default(now())
+  updatedAt           DateTime                   @updatedAt
+  plausibleAnalytics  PlausibleAnalytics?
+  minio               Minio?
+  vscodeserver        Vscodeserver?
+  wordpress           Wordpress?
+  ghost               Ghost?
+  serviceSecret       ServiceSecret[]
+  meiliSearch         MeiliSearch?
+  persistentStorage   ServicePersistentStorage[]
+  umami               Umami?
+  hasura              Hasura?
+  fider               Fider?
+}
+
+model PlausibleAnalytics {
+  id                   String   @id @default(cuid())
+  email                String?
+  username             String?
+  password             String
+  postgresqlUser       String
+  postgresqlPassword   String
+  postgresqlDatabase   String
+  postgresqlPublicPort Int?
+  secretKeyBase        String?
+  scriptName           String   @default("plausible.js")
+  serviceId            String   @unique
+  service              Service  @relation(fields: [serviceId], references: [id])
+  createdAt            DateTime @default(now())
+  updatedAt            DateTime @updatedAt
+}
+
+model Minio {
+  id               String   @id @default(cuid())
+  rootUser         String
+  rootUserPassword String
+  publicPort       Int?
+  apiFqdn          String?
+  serviceId        String   @unique
+  service          Service  @relation(fields: [serviceId], references: [id])
+  createdAt        DateTime @default(now())
+  updatedAt        DateTime @updatedAt
+}
+
+model Vscodeserver {
+  id        String   @id @default(cuid())
+  password  String
+  serviceId String   @unique
+  service   Service  @relation(fields: [serviceId], references: [id])
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}
+
+model Wordpress {
+  id                    String   @id @default(cuid())
+  extraConfig           String?
+  tablePrefix           String?
+  ownMysql              Boolean  @default(false)
+  mysqlHost             String?
+  mysqlPort             Int?
+  mysqlUser             String
+  mysqlPassword         String
+  mysqlRootUser         String
+  mysqlRootUserPassword String
+  mysqlDatabase         String?
+  mysqlPublicPort       Int?
+  ftpEnabled            Boolean  @default(false)
+  ftpUser               String?
+  ftpPassword           String?
+  ftpPublicPort         Int?
+  ftpHostKey            String?
+  ftpHostKeyPrivate     String?
+  serviceId             String   @unique
+  service               Service  @relation(fields: [serviceId], references: [id])
+  createdAt             DateTime @default(now())
+  updatedAt             DateTime @updatedAt
+}
+
+model Ghost {
+  id                      String   @id @default(cuid())
+  defaultEmail            String
+  defaultPassword         String
+  mariadbUser             String
+  mariadbPassword         String
+  mariadbRootUser         String
+  mariadbRootUserPassword String
+  mariadbDatabase         String?
+  mariadbPublicPort       Int?
+  serviceId               String   @unique
+  service                 Service  @relation(fields: [serviceId], references: [id])
+  createdAt               DateTime @default(now())
+  updatedAt               DateTime @updatedAt
+}
+
+model MeiliSearch {
+  id        String   @id @default(cuid())
+  masterKey String
+  serviceId String   @unique
+  service   Service  @relation(fields: [serviceId], references: [id])
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}
+
+model Umami {
+  id                   String   @id @default(cuid())
+  serviceId            String   @unique
+  postgresqlUser       String
+  postgresqlPassword   String
+  postgresqlDatabase   String
+  postgresqlPublicPort Int?
+  umamiAdminPassword   String
+  hashSalt             String
+  service              Service  @relation(fields: [serviceId], references: [id])
+  createdAt            DateTime @default(now())
+  updatedAt            DateTime @updatedAt
+}
+
+model Hasura {
+  id                   String   @id @default(cuid())
+  serviceId            String   @unique
+  postgresqlUser       String
+  postgresqlPassword   String
+  postgresqlDatabase   String
+  postgresqlPublicPort Int?
+  graphQLAdminPassword String
+  service              Service  @relation(fields: [serviceId], references: [id])
+  createdAt            DateTime @default(now())
+  updatedAt            DateTime @updatedAt
+}
+
+model Fider {
+  id                      String   @id @default(cuid())
+  serviceId               String   @unique
+  postgresqlUser          String
+  postgresqlPassword      String
+  postgresqlDatabase      String
+  postgresqlPublicPort    Int?
+  jwtSecret               String
+  emailNoreply            String?
+  emailMailgunApiKey      String?
+  emailMailgunDomain      String?
+  emailMailgunRegion      String   @default("EU")
+  emailSmtpHost           String?
+  emailSmtpPort           Int?
+  emailSmtpUser           String?
+  emailSmtpPassword       String?
+  emailSmtpEnableStartTls Boolean  @default(false)
+  service                 Service  @relation(fields: [serviceId], references: [id])
+  createdAt               DateTime @default(now())
+  updatedAt               DateTime @updatedAt
+}

apps/api/prisma/seed.js

@@ -0,0 +1,88 @@
+const dotEnvExtended = require('dotenv-extended');
+dotEnvExtended.load();
+const crypto = require('crypto');
+const generator = require('generate-password');
+const cuid = require('cuid');
+const { PrismaClient } = require('@prisma/client');
+const prisma = new PrismaClient();
+
+function generatePassword(length = 24) {
+	return generator.generate({
+		length,
+		numbers: true,
+		strict: true
+	});
+}
+const algorithm = 'aes-256-ctr';
+
+async function main() {
+	// Enable registration for the first user
+	// Set initial HAProxy password
+	const settingsFound = await prisma.setting.findFirst({});
+	if (!settingsFound) {
+		await prisma.setting.create({
+			data: {
+				isRegistrationEnabled: true,
+				proxyPassword: encrypt(generatePassword()),
+				proxyUser: cuid()
+			}
+		});
+	} else {
+		await prisma.setting.update({
+			where: {
+				id: settingsFound.id
+			},
+			data: {
+				isTraefikUsed: true,
+				proxyHash: null
+			}
+		});
+	}
+	const localDocker = await prisma.destinationDocker.findFirst({
+		where: { engine: '/var/run/docker.sock' }
+	});
+	if (!localDocker) {
+		await prisma.destinationDocker.create({
+			data: {
+				engine: '/var/run/docker.sock',
+				name: 'Local Docker',
+				isCoolifyProxyUsed: true,
+				network: 'coolify'
+			}
+		});
+	}
+
+	// Set auto-update based on env variable
+	const isAutoUpdateEnabled = process.env['COOLIFY_AUTO_UPDATE'] === 'true';
+	const settings = await prisma.setting.findFirst({});
+	if (settings) {
+		await prisma.setting.update({
+			where: {
+				id: settings.id
+			},
+			data: {
+				isAutoUpdateEnabled
+			}
+		});
+	}
+}
+main()
+	.catch((e) => {
+		console.error(e);
+		process.exit(1);
+	})
+	.finally(async () => {
+		await prisma.$disconnect();
+	});
+
+const encrypt = (text) => {
+	if (text) {
+		const iv = crypto.randomBytes(16);
+		const cipher = crypto.createCipheriv(algorithm, process.env['COOLIFY_SECRET_KEY'], iv);
+		const encrypted = Buffer.concat([cipher.update(text), cipher.final()]);
+		return JSON.stringify({
+			iv: iv.toString('hex'),
+			content: encrypted.toString('hex')
+		});
+	}
+};

apps/api/src/index.ts

@@ -0,0 +1,132 @@
+import Fastify from 'fastify';
+import cors from '@fastify/cors';
+import serve from '@fastify/static';
+import env from '@fastify/env';
+import cookie from '@fastify/cookie';
+import path, { join } from 'path';
+import autoLoad from '@fastify/autoload';
+import { asyncExecShell, isDev, prisma } from './lib/common';
+import { scheduler } from './lib/scheduler';
+
+declare module 'fastify' {
+	interface FastifyInstance {
+		config: {
+			COOLIFY_APP_ID: string,
+			COOLIFY_SECRET_KEY: string,
+			COOLIFY_DATABASE_URL: string,
+			COOLIFY_SENTRY_DSN: string,
+			COOLIFY_IS_ON: string,
+			COOLIFY_WHITE_LABELED: boolean,
+			COOLIFY_WHITE_LABELED_ICON: string | null,
+			COOLIFY_AUTO_UPDATE: boolean,
+		};
+	}
+}
+
+const port = isDev ? 3001 : 3000;
+const host = '0.0.0.0';
+const fastify = Fastify({
+	logger: false
+});
+const schema = {
+	type: 'object',
+	required: ['COOLIFY_SECRET_KEY', 'COOLIFY_DATABASE_URL', 'COOLIFY_IS_ON'],
+	properties: {
+		COOLIFY_APP_ID: {
+			type: 'string',
+		},
+		COOLIFY_SECRET_KEY: {
+			type: 'string',
+		},
+		COOLIFY_DATABASE_URL: {
+			type: 'string',
+			default: 'file:../db/dev.db'
+		},
+		COOLIFY_SENTRY_DSN: {
+			type: 'string',
+			default: null
+		},
+		COOLIFY_IS_ON: {
+			type: 'string',
+			default: 'docker'
+		},
+		COOLIFY_WHITE_LABELED: {
+			type: 'boolean',
+			default: false
+		},
+		COOLIFY_WHITE_LABELED_ICON: {
+			type: 'string',
+			default: null
+		},
+		COOLIFY_AUTO_UPDATE: {
+			type: 'boolean',
+			default: false
+		},
+
+	}
+};
+
+const options = {
+	schema
+};
+fastify.register(env, options);
+if (!isDev) {
+	fastify.register(serve, {
+		root: path.join(__dirname, './public'),
+		preCompressed: true
+	});
+	fastify.setNotFoundHandler(function (request, reply) {
+		if (request.raw.url && request.raw.url.startsWith('/api')) {
+			return reply.status(404).send({
+				success: false
+			});
+		}
+		return reply.status(200).sendFile('index.html');
+	});
+}
+fastify.register(autoLoad, {
+	dir: join(__dirname, 'plugins')
+});
+fastify.register(autoLoad, {
+	dir: join(__dirname, 'routes')
+});
+
+fastify.register(cookie)
+fastify.register(cors);
+fastify.listen({ port, host }, async (err: any, address: any) => {
+	if (err) {
+		console.error(err);
+		process.exit(1);
+	}
+	console.log(`Coolify's API is listening on ${host}:${port}`);
+	await initServer()
+	await scheduler.start('deployApplication');
+	await scheduler.start('cleanupStorage');
+	await scheduler.start('checkProxies')
+
+	// Check if no build is running, try to autoupdate.
+	setInterval(async () => {
+		const { isAutoUpdateEnabled } = await prisma.setting.findFirst();
+		if (isAutoUpdateEnabled) {
+			if (scheduler.workers.has('deployApplication')) {
+				scheduler.workers.get('deployApplication').postMessage("status");
+			}
+		}
+	}, 30000 * 10)
+
+	scheduler.on('worker deleted', async (name) => {
+		if (name === 'autoUpdater') {
+			await scheduler.start('deployApplication');
+		}
+
+	});
+
+});
+
+async function initServer() {
+	try {
+		await asyncExecShell(`docker network create --attachable coolify`);
+	} catch (error) { }
+}
+
+