chore: version++

v3.1.3

.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,33 @@
+// 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",
+		"ardenivanov.svelte-intellisense",
+		"Prisma.prisma"
+	],
+	// 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,12 @@
+.DS_Store
 node_modules
+build
+.svelte-kit
+package
+.env
+.env.*
+!.env.example
 dist
-.routify
+client
+apps/api/db/*.db
+local-serve

.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/production-release.yml

@@ -0,0 +1,37 @@
+name: production-release
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  making-something-cool:
+    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
+      - uses: sarisia/actions-status-discord@v1
+        if: always()
+        with:
+          webhook: ${{ secrets.DISCORD_WEBHOOK_DEV_CHANNEL }}

.github/workflows/staging-release.yml

@@ -0,0 +1,35 @@
+name: staging-release
+
+on:
+  push:
+    branches:
+      - next
+
+jobs:
+  staging-release:
+    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: Build and push
+        uses: docker/build-push-action@v2
+        with:
+          context: .
+          platforms: linux/amd64
+          push: true
+          tags: coollabsio/coolify:next
+          cache-from: type=registry,ref=coollabsio/coolify:buildcache-next
+          cache-to: type=registry,ref=coollabsio/coolify:buildcache-next,mode=max
+      - uses: sarisia/actions-status-discord@v1
+        if: always()
+        with:
+          webhook: ${{ secrets.DISCORD_WEBHOOK_DEV_CHANNEL }}

.gitignore

@@ -1,11 +1,13 @@
-.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
-yarn.lock
+.env.*
+!.env.example
+dist
+client
+apps/api/db/*.db
+local-serve
+apps/api/db/migration.db-journal

.gitpod.yml

@@ -0,0 +1,11 @@
+# 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.
+image: gitpod/workspace-node:2022-06-20-19-54-55
+tasks:
+  - init: pnpm install && pnpm db:push && pnpm db:seed
+    command: pnpm dev
+
+ports:
+  - port: 3001
+    visibility: public

.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,93 +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 is a buildpack?
+## Feedback
 
-A: It defines your application's final form. 
-`Static` means that it will be hosted as a static site.
-`NodeJs` means that it will be started as a node application.
+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!
 
-# Screenshots
+## How to install
 
-[Login](https://coollabs.io/coolify/login.jpg)
+Installation is automated with the following command:
 
-[Applications](https://coollabs.io/coolify/applications.jpg)
+```bash
+wget -q https://get.coollabs.io/coolify/install.sh -O install.sh; sudo bash ./install.sh
+```
 
-[Databases](https://coollabs.io/coolify/databases.jpg)
+If you would like no questions during installation:
 
-[Configuration](https://coollabs.io/coolify/configuration.jpg)
+```bash
+wget -q https://get.coollabs.io/coolify/install.sh -O install.sh; sudo bash ./install.sh -f
+```
 
-[Settings](https://coollabs.io/coolify/settings.jpg)
+For more details goto the [docs](https://docs.coollabs.io/coolify/installation).
 
-[Logs](https://coollabs.io/coolify/logs.jpg)
+## Features
 
-# Getting Started
+ARM support is in beta!
 
-Automatically: `sh <(curl -fsSL https://get.coollabs.io/install.sh) coolify`
+### Git Sources
 
-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 use the following Git Sources to be auto-deployed to your Coolifyt instance! (Self-hosted versions are also supported.)
 
-  - GitHub App name: could be anything weird
-  - Homepage URL: https://yourdomain
+- Github
+- GitLab
+- Bitbucket (WIP)
 
-  Identifying and authorizing users: 
-  - Callback URL: https://yourdomain/api/v1/login/github/app
-  - Request user authorization (OAuth) during installation -> Check!
+### Destinations
 
-  Webhook:
-  - Active -> Check!
-  - Webhook URL: https://yourdomain/api/v1/webhooks/deploy
-  - Webhook Secret: it should be super secret
+You can deploy your applications to the following destinations:
 
-  Repository permissions:
-  - Contents: Read-only
-  - Metadata: Read-only
-  
-  User permissions: 
-  - Email: Read-only
+- Local Docker Engine
+- Remote Docker Engine (WIP)
+- Kubernetes (WIP)
 
-  Subscribe to events: 
-  - Push -> Check!
+### Applications
 
-### Installation
-- Clone this repository: `git clone git@github.com:coollabsio/coolify.git`
-- Set `.env` (see `.env.template`)
-- Installation: `bash install.sh all`
+These are the predefined build packs, but with the Docker build pack, you can host anything that is hostable with a single Dockerfile.
 
-## Manual updating process (You probably never need to do this!)
-### Update everything (proxy+coolify)
--  `bash install.sh all`
+- Static sites
+- NodeJS
+- VueJS
+- NuxtJS
+- NextJS
+- React/Preact
+- Gatsby
+- Svelte
+- PHP
+- Laravel
+- Rust
+- Docker
+- Python
+- Deno
 
-### Update coolify only
--  `bash install.sh coolify`
+### Databases
 
-### Update proxy only
--  `bash install.sh proxy`
+One-click database is ready to be used internally or shared over the internet:
+
+- MongoDB
+- MariaDB
+- MySQL
+- PostgreSQL
+- CouchDB
+- Redis
+
+### One-click services
+
+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,42 +0,0 @@
-const { docker } = require('../../docker')
-const { execShellAsync } = require('../../common')
-const Deployment = require('../../../models/Deployment')
-
-async function purgeOldThings () {
-  try {
-    // TODO: Tweak this, because it deletes coolify-base, so the upgrade will be slow
-    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,88 +0,0 @@
-const { uniqueNamesGenerator, adjectives, colors, animals } = require('unique-names-generator')
-const cuid = require('cuid')
-const crypto = require('crypto')
-
-const { execShellAsync } = require('../common')
-
-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')
-
-    const baseServiceConfiguration = {
-      replicas: 1,
-      restart_policy: {
-        condition: 'any',
-        max_attempts: 3
-      },
-      update_config: {
-        parallelism: 1,
-        delay: '10s',
-        order: 'start-first'
-      },
-      rollback_config: {
-        parallelism: 1,
-        delay: '10s',
-        order: 'start-first'
-      }
-    }
-
-    configuration.build.container.name = sha256.slice(0, 15)
-
-    configuration.general.nickname = nickname
-    configuration.general.deployId = deployId
-    configuration.general.workdir = `/tmp/${deployId}`
-
-    if (!configuration.publish.path) configuration.publish.path = '/'
-    if (!configuration.publish.port) {
-      if (configuration.build.pack === 'php') {
-        configuration.publish.port = 80
-      } else if (configuration.build.pack === 'static') {
-        configuration.publish.port = 80
-      } else if (configuration.build.pack === 'nodejs') {
-        configuration.publish.port = 3000
-      }
-    }
-    if (!configuration.build.directory) {
-      configuration.build.directory = '/'
-    }
-    if (configuration.build.pack === 'static' || configuration.build.pack === 'nodejs') {
-      if (!configuration.build.command.installation) configuration.build.command.installation = 'yarn install'
-    }
-
-    configuration.build.container.baseSHA = crypto.createHash('sha256').update(JSON.stringify(baseServiceConfiguration)).digest('hex')
-    configuration.baseServiceConfiguration = baseServiceConfiguration
-
-    return configuration
-  } catch (error) {
-    throw { error, type: 'server' }
-  }
-}
-
-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,83 +0,0 @@
-const yaml = require('js-yaml')
-const fs = require('fs').promises
-const { execShellAsync } = require('../../common')
-const { docker } = require('../../docker')
-const { saveAppLog } = require('../../logging')
-const { deleteSameDeployments } = require('../cleanup')
-
-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
-
-    // Only save SHA256 of it in the configuration label
-    const baseServiceConfiguration = configuration.baseServiceConfiguration
-    delete configuration.baseServiceConfiguration
-
-    const stack = {
-      version: '3.8',
-      services: {
-        [containerName]: {
-          image: `${configuration.build.container.name}:${configuration.build.container.tag}`,
-          networks: [`${docker.network}`],
-          environment: generateEnvs,
-          deploy: {
-            ...baseServiceConfiguration,
-            labels: [
-              'managedBy=coolify',
-              'type=application',
-              'configuration=' + JSON.stringify(configuration),
-              'traefik.enable=true',
-              'traefik.http.services.' +
-              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))
-    // TODO: Compare stack.yml with the currently running one to upgrade if something changes, like restart_policy
-    if (imageChanged) {
-      // console.log('image changed')
-      await execShellAsync(`docker service update --image ${configuration.build.container.name}:${configuration.build.container.tag} ${configuration.build.container.name}_${configuration.build.container.name}`)
-    } else {
-      // console.log('new deployment or force deployment or config changed')
-      await deleteSameDeployments(configuration)
-      await execShellAsync(
-        `cat ${configuration.general.workdir}/stack.yml | docker stack deploy --prune -c - ${containerName}`
-      )
-    }
-
-    await saveAppLog('### Published done!', configuration)
-  } catch (error) {
-    console.log(error)
-    await saveAppLog(`Error occured during deployment: ${error.message}`, configuration)
-    throw { error, type: 'server' }
-  }
-}

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/custom/index.js

@@ -1,15 +0,0 @@
-const fs = require('fs').promises
-const { streamEvents, docker } = require('../../libs/docker')
-
-module.exports = async function (configuration) {
-  const path = `${configuration.general.workdir}/${configuration.build.directory ? configuration.build.directory : ''}`
-  if (fs.stat(`${path}/Dockerfile`)) {
-    const stream = await docker.engine.buildImage(
-      { src: ['.'], context: path },
-      { t: `${configuration.build.container.name}:${configuration.build.container.tag}` }
-    )
-    await streamEvents(stream, configuration)
-  } else {
-    throw { error: 'No custom dockerfile found.', type: 'app' }
-  }
-}

api/packs/helpers.js

@@ -1,23 +0,0 @@
-const fs = require('fs').promises
-const { streamEvents, docker } = require('../libs/docker')
-const buildImageNodeDocker = (configuration) => {
-  return [
-    'FROM node:lts',
-    'WORKDIR /usr/src/app',
-    `COPY ${configuration.build.directory} ./`,
-    configuration.build.command.installation && `RUN ${configuration.build.command.installation}`,
-    `RUN ${configuration.build.command.build}`
-  ].join('\n')
-}
-async function buildImage (configuration) {
-  await fs.writeFile(`${configuration.general.workdir}/Dockerfile`, buildImageNodeDocker(configuration))
-  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,6 +0,0 @@
-const static = require('./static')
-const nodejs = require('./nodejs')
-const php = require('./php')
-const custom = require('./custom')
-
-module.exports = { static, nodejs, php, custom }

api/packs/nodejs/index.js

@@ -1,26 +0,0 @@
-const fs = require('fs').promises
-const { buildImage } = require('../helpers')
-const { streamEvents, docker } = require('../../libs/docker')
-
-const publishNodejsDocker = (configuration) => {
-  return [
-    'FROM node:lts',
-    'WORKDIR /usr/src/app',
-    configuration.build.command.build
-      ? `COPY --from=${configuration.build.container.name}:${configuration.build.container.tag} /usr/src/app/${configuration.publish.directory} ./`
-      : `COPY ${configuration.build.directory} ./`,
-    configuration.build.command.installation && `RUN ${configuration.build.command.installation}`,
-    `EXPOSE ${configuration.publish.port}`,
-    'CMD [ "yarn", "start" ]'
-  ].join('\n')
-}
-
-module.exports = async function (configuration) {
-  if (configuration.build.command.build) await buildImage(configuration)
-  await fs.writeFile(`${configuration.general.workdir}/Dockerfile`, publishNodejsDocker(configuration))
-  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/php/index.js

@@ -1,21 +0,0 @@
-const fs = require('fs').promises
-const { streamEvents, docker } = require('../../libs/docker')
-
-const publishPHPDocker = (configuration) => {
-  return [
-    'FROM php:apache',
-    'WORKDIR /usr/src/app',
-    `COPY .${configuration.build.directory} /var/www/html`,
-    'EXPOSE 80',
-    ' CMD ["apache2-foreground"]'
-  ].join('\n')
-}
-
-module.exports = async function (configuration) {
-  await fs.writeFile(`${configuration.general.workdir}/Dockerfile`, publishPHPDocker(configuration))
-  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,27 +0,0 @@
-const fs = require('fs').promises
-const { buildImage } = require('../helpers')
-const { streamEvents, docker } = require('../../libs/docker')
-
-const publishStaticDocker = (configuration) => {
-  return [
-    'FROM nginx:stable-alpine',
-    'COPY nginx.conf /etc/nginx/nginx.conf',
-    'WORKDIR /usr/share/nginx/html',
-    configuration.build.command.build
-      ? `COPY --from=${configuration.build.container.name}:${configuration.build.container.tag} /usr/src/app/${configuration.publish.directory} ./`
-      : `COPY ${configuration.build.directory} ./`,
-    'EXPOSE 80',
-    'CMD ["nginx", "-g", "daemon off;"]'
-  ].join('\n')
-}
-
-module.exports = async function (configuration) {
-  if (configuration.build.command.build) await buildImage(configuration)
-  await fs.writeFile(`${configuration.general.workdir}/Dockerfile`, publishStaticDocker(configuration))
-
-  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,121 +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) {
-          // Base service configuration changed
-          if (!running.build.container.baseSHA || running.build.container.baseSHA !== configuration.build.container.baseSHA) {
-            configChanged = true
-          }
-          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,61 +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) => {
-    try {
-      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
-        }
-      }
-    } catch (error) {
-      if (error.code === 'ENOENT' && error.errno === -2) {
-        throw new Error(`Docker service unavailable at ${error.address}.`)
-      }
-    }
-  })
-}

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' \\)` --minify=true --platform=node --outdir=build --format=cjs  && node build",
+    "legacyWatch": true
+  }

apps/api/package.json

@@ -0,0 +1,68 @@
+{
+  "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",
+    "db:migrate": "COOLIFY_DATABASE_URL=file:../db/migration.db prisma migrate dev --skip-seed --name",
+    "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.1.0",
+    "@fastify/cookie": "7.1.0",
+    "@fastify/cors": "8.0.0",
+    "@fastify/env": "4.0.0",
+    "@fastify/jwt": "6.3.1",
+    "@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.1",
+    "fastify-plugin": "4.0.0",
+    "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.4",
+    "@types/node-os-utils": "1.3.0",
+    "@typescript-eslint/eslint-plugin": "5.30.6",
+    "@typescript-eslint/parser": "5.30.6",
+    "esbuild": "0.14.49",
+    "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/20220708132655_deployment_type_for_applications/migration.sql

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