Merge pull request #1030 from coollabsio/next

v3.12.30

.github/workflows/production-release-dockerhub.yml

@@ -1,8 +1,9 @@
 name: Production Release to DockerHub
 
 on:
-  release:
+  push:
-    types: [released]
+    branches:
+      - "this-branch-does-not-exists"
 
 jobs:
   arm64:

.github/workflows/staging-release-dockerhub.yml

@@ -3,7 +3,7 @@ name: Staging Release to DockerHub
 on:
   push:
     branches:
-      - "next"
+      - "this-branch-does-not-exists"
 
 jobs:
   arm64:

.github/workflows/staging-release.yml

@@ -1,23 +1,24 @@
 name: Staging Release to ghcr.io
-
+concurrency:
+  group: staging_environment
+  cancel-in-progress: true
 on:
   push:
     branches-ignore:
       - "main"
+      - "v4"
 env:
   REGISTRY: ghcr.io
   IMAGE_NAME: "coollabsio/coolify"
 
 jobs:
   amd64:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
       - name: Checkout
         uses: actions/checkout@v3
         with:
           ref: "next"
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v2
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v2
       - name: Login to ghcr.io
@@ -40,14 +41,13 @@ jobs:
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}
   aarch64:
-    runs-on: [self-hosted, arm64]
+    runs-on:
+      group: aarch-runners
     steps:
       - name: Checkout
         uses: actions/checkout@v3
         with:
           ref: "next"
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v2
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v2
       - name: Login to ghcr.io

README.md

@@ -100,7 +100,7 @@ Deploy your resource to:
 
 - Mastodon: [@andrasbacsai@fosstodon.org](https://fosstodon.org/@andrasbacsai)
 - Telegram: [@andrasbacsai](https://t.me/andrasbacsai)
-- Twitter: [@andrasbacsai](https://twitter.com/andrasbacsai)
+- Twitter: [@andrasbacsai](https://twitter.com/heyandras)
 - Email: [andras@coollabs.io](mailto:andras@coollabs.io)
 - Discord: [Invitation](https://coollabs.io/discord)
 

apps/api/devTemplates.yaml

@@ -414,6 +414,7 @@
       proxy:
         - port: "22"
           hostPort: $$config_hostport_ssh
+        - port: "3000"
   variables:
     - id: $$config_hostport_ssh
       name: SSH_PORT

apps/api/src/index.ts

@@ -306,7 +306,7 @@ async function initServer() {
 	} catch (error) {}
 	try {
 		console.log('[003] Cleaning up old build sources under /tmp/build-sources/...');
-		await fs.rm('/tmp/build-sources', { recursive: true, force: true });
+		if (!isDev) await fs.rm('/tmp/build-sources', { recursive: true, force: true });
 	} catch (error) {
 		console.log(error);
 	}

apps/api/src/jobs/deployApplication.ts

@@ -240,7 +240,7 @@ import * as buildpacks from '../lib/buildPacks';
 											applicationId: application.id
 										});
 									}
-									await fs.rm(workdir, { recursive: true, force: true });
+									if (!isDev) await fs.rm(workdir, { recursive: true, force: true });
 									return;
 								}
 								try {
@@ -263,7 +263,7 @@ import * as buildpacks from '../lib/buildPacks';
 										await saveBuildLog({ line: error.stderr, buildId, applicationId });
 									}
 								} finally {
-									await fs.rm(workdir, { recursive: true, force: true });
+									if (!isDev) await fs.rm(workdir, { recursive: true, force: true });
 									await prisma.build.update({
 										where: { id: buildId },
 										data: { status: 'success' }
@@ -782,7 +782,7 @@ import * as buildpacks from '../lib/buildPacks';
 										applicationId: application.id
 									});
 								}
-								await fs.rm(workdir, { recursive: true, force: true });
+								if (!isDev) await fs.rm(workdir, { recursive: true, force: true });
 								return;
 							}
 							try {
@@ -803,7 +803,7 @@ import * as buildpacks from '../lib/buildPacks';
 									await saveBuildLog({ line: error.stderr, buildId, applicationId });
 								}
 							} finally {
-								await fs.rm(workdir, { recursive: true, force: true });
+								if (!isDev) await fs.rm(workdir, { recursive: true, force: true });
 								await prisma.build.update({ where: { id: buildId }, data: { status: 'success' } });
 							}
 						});

apps/api/src/lib/buildPacks/common.ts

@@ -804,6 +804,7 @@ export async function buildCacheImageWithNode(data, imageForBuild) {
 		Dockerfile.push(`RUN ${installCommand}`);
 	}
 	Dockerfile.push(`RUN ${buildCommand}`);
+	Dockerfile.push('RUN rm -fr .git');
 	await fs.writeFile(`${workdir}/Dockerfile-cache`, Dockerfile.join('\n'));
 	await buildImage({ ...data, isCache: true });
 }
@@ -821,6 +822,7 @@ export async function buildCacheImageForLaravel(data, imageForBuild) {
 	}
 	Dockerfile.push(`COPY *.json *.mix.js /app/`);
 	Dockerfile.push(`COPY resources /app/resources`);
+	Dockerfile.push('RUN rm -fr .git');
 	Dockerfile.push(`RUN yarn install && yarn production`);
 	await fs.writeFile(`${workdir}/Dockerfile-cache`, Dockerfile.join('\n'));
 	await buildImage({ ...data, isCache: true });
@@ -842,6 +844,7 @@ export async function buildCacheImageWithCargo(data, imageForBuild) {
 	Dockerfile.push('RUN cargo install cargo-chef');
 	Dockerfile.push(`COPY --from=planner-${applicationId} /app/recipe.json recipe.json`);
 	Dockerfile.push('RUN cargo chef cook --release --recipe-path recipe.json');
+	Dockerfile.push('RUN rm -fr .git');
 	await fs.writeFile(`${workdir}/Dockerfile-cache`, Dockerfile.join('\n'));
 	await buildImage({ ...data, isCache: true });
 }

apps/api/src/lib/buildPacks/compose.ts

@@ -47,7 +47,12 @@ export default async function (data) {
 	for (let [key, value] of Object.entries(dockerComposeYaml.services)) {
 		value['container_name'] = `${applicationId}-${key}`;
 
+		if (value['env_file']) {
+			delete value['env_file'];
+		}
+
 		let environment = typeof value['environment'] === 'undefined' ? [] : value['environment'];
+		console.log({ key, environment });
 		if (Object.keys(environment).length > 0) {
 			environment = Object.entries(environment).map(([key, value]) => `${key}=${value}`);
 		}
@@ -60,7 +65,7 @@ export default async function (data) {
 		const buildArgs = typeof build['args'] === 'undefined' ? [] : build['args'];
 		let finalArgs = [...buildEnvs];
 		if (Object.keys(buildArgs).length > 0) {
-			for (const arg of buildArgs) {
+			for (const arg of Object.keys(buildArgs)) {
 				const [key, _] = arg.split('=');
 				if (finalArgs.filter((env) => env.startsWith(key)).length === 0) {
 					finalArgs.push(arg);
@@ -87,7 +92,10 @@ export default async function (data) {
 						v.startsWith('~') ||
 						v.startsWith('$PWD')
 					) {
-						v = v.replace(/^\./, `~`).replace(/^\.\./, '~').replace(/^\$PWD/, '~');
+						v = v
+							.replace(/^\./, `~`)
+							.replace(/^\.\./, '~')
+							.replace(/^\$PWD/, '~');
 					} else {
 						if (!path) {
 							path = v;
@@ -110,10 +118,11 @@ export default async function (data) {
 						source.startsWith('~') ||
 						source.startsWith('$PWD')
 					) {
-
+						source = source
-						source = source.replace(/^\./, `~`).replace(/^\.\./, '~').replace(/^\$PWD/, '~');
+							.replace(/^\./, `~`)
-						console.log({source})
+							.replace(/^\.\./, '~')
-
+							.replace(/^\$PWD/, '~');
+						console.log({ source });
 					} else {
 						if (!target) {
 							target = source;
@@ -125,7 +134,6 @@ export default async function (data) {
 
 					return `${source}:${target}${mode ? ':' + mode : ''}`;
 				}
-
 			});
 		}
 		if (volumes.length > 0) {
@@ -136,16 +144,20 @@ export default async function (data) {
 		if (dockerComposeConfiguration[key]?.port) {
 			value['expose'] = [dockerComposeConfiguration[key].port];
 		}
-		if (value['networks']?.length > 0) {
+		value['networks'] = [network];
-			value['networks'].forEach((network) => {
+		if (value['build']?.network) {
-				networks[network] = {
+			delete value['build']['network'];
-					name: network
-				};
-			});
-			value['networks'] = [...(value['networks'] || ''), network];
-		} else {
-			value['networks'] = [network];
 		}
+		// if (value['networks']?.length > 0) {
+		// 	value['networks'].forEach((network) => {
+		// 		networks[network] = {
+		// 			name: network
+		// 		};
+		// 	});
+		// 	value['networks'] = [...(value['networks'] || ''), network];
+		// } else {
+		// 	value['networks'] = [network];
+		// }
 
 		dockerComposeYaml.services[key] = {
 			...dockerComposeYaml.services[key],

apps/api/src/lib/buildPacks/deno.ts

@@ -36,6 +36,7 @@ const createDockerfile = async (data, image): Promise<void> => {
 	Dockerfile.push(`COPY .${baseDirectory || ''} ./`);
 	Dockerfile.push(`RUN deno cache ${denoMainFile}`);
 	Dockerfile.push(`ENV NO_COLOR true`);
+	Dockerfile.push('RUN rm -fr .git');
 	Dockerfile.push(`EXPOSE ${port}`);
 	Dockerfile.push(`CMD deno run ${denoOptions || ''} ${denoMainFile}`);
 	await fs.writeFile(`${workdir}/Dockerfile`, Dockerfile.join('\n'));

apps/api/src/lib/buildPacks/docker.ts

@@ -22,6 +22,7 @@ export default async function (data) {
 			});
 		});
 	}
+	Dockerfile.push(`RUN rm -fr .git`);
 	await fs.writeFile(`${data.workdir}${dockerFileLocation}`, Dockerfile.join('\n'));
 	await buildImage(data);
 }

apps/api/src/lib/buildPacks/gatsby.ts

@@ -12,6 +12,7 @@ const createDockerfile = async (data, imageforBuild): Promise<void> => {
 	if (baseImage?.includes('nginx')) {
 		Dockerfile.push(`COPY /nginx.conf /etc/nginx/nginx.conf`);
 	}
+	Dockerfile.push('RUN rm -fr .git');
 	Dockerfile.push(`EXPOSE ${port}`);
 	await fs.writeFile(`${workdir}/Dockerfile`, Dockerfile.join('\n'));
 };

apps/api/src/lib/buildPacks/laravel.ts

@@ -30,6 +30,7 @@ const createDockerfile = async (data, image): Promise<void> => {
 		`COPY --chown=application:application --from=${applicationId}:${tag}-cache /app/mix-manifest.json /app/public/mix-manifest.json`
 	);
 	Dockerfile.push(`COPY --chown=application:application . ./`);
+	Dockerfile.push('RUN rm -fr .git');
 	Dockerfile.push(`EXPOSE ${port}`);
 	await fs.writeFile(`${workdir}/Dockerfile`, Dockerfile.join('\n'));
 };

apps/api/src/lib/buildPacks/nestjs.ts

@@ -13,7 +13,7 @@ const createDockerfile = async (data, image): Promise<void> => {
 		Dockerfile.push('RUN curl -f https://get.pnpm.io/v6.16.js | node - add --global pnpm@7');
 	}
 	Dockerfile.push(`COPY --from=${applicationId}:${tag}-cache /app${publishDirectory} ./`);
-
+	Dockerfile.push('RUN rm -fr .git');
 	Dockerfile.push(`EXPOSE ${port}`);
 	Dockerfile.push(`CMD ${startCommand}`);
 	await fs.writeFile(`${workdir}/Dockerfile`, Dockerfile.join('\n'));

apps/api/src/lib/buildPacks/nextjs.ts

@@ -36,6 +36,7 @@ const createDockerfile = async (data, image): Promise<void> => {
 		Dockerfile.push(`COPY .${baseDirectory || ''} ./`);
 		Dockerfile.push(`RUN ${installCommand}`);
 		Dockerfile.push(`RUN ${buildCommand}`);
+		Dockerfile.push('RUN rm -fr .git');
 		Dockerfile.push(`EXPOSE ${port}`);
 		Dockerfile.push(`CMD ${startCommand}`);
 	} else if (deploymentType === 'static') {
@@ -43,6 +44,7 @@ const createDockerfile = async (data, image): Promise<void> => {
 			Dockerfile.push(`COPY /nginx.conf /etc/nginx/nginx.conf`);
 		}
 		Dockerfile.push(`COPY --from=${applicationId}:${tag}-cache /app${publishDirectory} ./`);
+		Dockerfile.push('RUN rm -fr .git');
 		Dockerfile.push(`EXPOSE 80`);
 	}
 

apps/api/src/lib/buildPacks/node.ts

@@ -34,6 +34,7 @@ const createDockerfile = async (data, image): Promise<void> => {
 		Dockerfile.push(`RUN ${buildCommand}`);
 	}
 	Dockerfile.push(`EXPOSE ${port}`);
+	Dockerfile.push('RUN rm -fr .git');
 	Dockerfile.push(`CMD ${startCommand}`);
 	await fs.writeFile(`${workdir}/Dockerfile`, Dockerfile.join('\n'));
 };

apps/api/src/lib/buildPacks/nuxtjs.ts

@@ -36,6 +36,7 @@ const createDockerfile = async (data, image): Promise<void> => {
 		Dockerfile.push(`COPY .${baseDirectory || ''} ./`);
 		Dockerfile.push(`RUN ${installCommand}`);
 		Dockerfile.push(`RUN ${buildCommand}`);
+		Dockerfile.push('RUN rm -fr .git');
 		Dockerfile.push(`EXPOSE ${port}`);
 		Dockerfile.push(`CMD ${startCommand}`);
 	} else if (deploymentType === 'static') {
@@ -43,6 +44,7 @@ const createDockerfile = async (data, image): Promise<void> => {
 			Dockerfile.push(`COPY /nginx.conf /etc/nginx/nginx.conf`);
 		}
 		Dockerfile.push(`COPY --from=${applicationId}:${tag}-cache /app${publishDirectory} ./`);
+		Dockerfile.push('RUN rm -fr .git');
 		Dockerfile.push(`EXPOSE 80`);
 	}
 

apps/api/src/lib/buildPacks/php.ts

@@ -28,6 +28,7 @@ const createDockerfile = async (data, image, htaccessFound): Promise<void> => {
 	}
 
 	Dockerfile.push(`COPY /entrypoint.sh /opt/docker/provision/entrypoint.d/30-entrypoint.sh`);
+	Dockerfile.push('RUN rm -fr .git');
 	Dockerfile.push(`EXPOSE ${port}`);
 	await fs.writeFile(`${workdir}/Dockerfile`, Dockerfile.join('\n'));
 };

apps/api/src/lib/buildPacks/python.ts

@@ -52,7 +52,7 @@ const createDockerfile = async (data, image): Promise<void> => {
 	} else {
 		Dockerfile.push(`CMD python ${pythonModule}`);
 	}
-
+	Dockerfile.push('RUN rm -fr .git');
 	await fs.writeFile(`${workdir}/Dockerfile`, Dockerfile.join('\n'));
 };
 

apps/api/src/lib/buildPacks/react.ts

@@ -12,6 +12,7 @@ const createDockerfile = async (data, image): Promise<void> => {
 	if (baseImage?.includes('nginx')) {
 		Dockerfile.push(`COPY /nginx.conf /etc/nginx/nginx.conf`);
 	}
+	Dockerfile.push('RUN rm -fr .git');
 	Dockerfile.push(`EXPOSE ${port}`);
 	await fs.writeFile(`${workdir}/Dockerfile`, Dockerfile.join('\n'));
 };

apps/api/src/lib/buildPacks/rust.ts

@@ -20,6 +20,7 @@ const createDockerfile = async (data, image, name): Promise<void> => {
 	);
 	Dockerfile.push(`RUN update-ca-certificates`);
 	Dockerfile.push(`COPY --from=${applicationId}:${tag}-cache /app/target/release/${name} ${name}`);
+	Dockerfile.push('RUN rm -fr .git');
 	Dockerfile.push(`EXPOSE ${port}`);
 	Dockerfile.push(`CMD ["/app/${name}"]`);
 	await fs.writeFile(`${workdir}/Dockerfile`, Dockerfile.join('\n'));

apps/api/src/lib/buildPacks/static.ts

@@ -38,6 +38,7 @@ const createDockerfile = async (data, image): Promise<void> => {
 	if (baseImage?.includes('nginx')) {
 		Dockerfile.push(`COPY /nginx.conf /etc/nginx/nginx.conf`);
 	}
+	Dockerfile.push('RUN rm -fr .git');
 	Dockerfile.push(`EXPOSE ${port}`);
 	await fs.writeFile(`${workdir}/Dockerfile`, Dockerfile.join('\n'));
 };

apps/api/src/lib/buildPacks/svelte.ts

@@ -12,6 +12,7 @@ const createDockerfile = async (data, image): Promise<void> => {
 	if (baseImage?.includes('nginx')) {
 		Dockerfile.push(`COPY /nginx.conf /etc/nginx/nginx.conf`);
 	}
+	Dockerfile.push('RUN rm -fr .git');
 	Dockerfile.push(`EXPOSE ${port}`);
 	await fs.writeFile(`${workdir}/Dockerfile`, Dockerfile.join('\n'));
 };

apps/api/src/lib/buildPacks/vuejs.ts

@@ -12,6 +12,7 @@ const createDockerfile = async (data, image): Promise<void> => {
 	if (baseImage?.includes('nginx')) {
 		Dockerfile.push(`COPY /nginx.conf /etc/nginx/nginx.conf`);
 	}
+	Dockerfile.push('RUN rm -fr .git');
 	Dockerfile.push(`EXPOSE ${port}`);
 	await fs.writeFile(`${workdir}/Dockerfile`, Dockerfile.join('\n'));
 };

apps/api/src/lib/common.ts

@@ -19,7 +19,7 @@ import { saveBuildLog } from './buildPacks/common';
 import { scheduler } from './scheduler';
 import type { ExecaChildProcess } from 'execa';
 
-export const version = '3.12.28';
+export const version = '3.12.30';
 export const isDev = process.env.NODE_ENV === 'development';
 export const proxyPort = process.env.COOLIFY_PROXY_PORT;
 export const proxySecurePort = process.env.COOLIFY_PROXY_SECURE_PORT;
@@ -402,8 +402,8 @@ export const supportedDatabaseTypesAndVersions = [
 		fancyName: 'MongoDB',
 		baseImage: 'bitnami/mongodb',
 		baseImageARM: 'mongo',
-		versions: ['5.0', '4.4', '4.2'],
+		versions: ['6.0', '5.0', '4.4', '4.2'],
-		versionsARM: ['5.0', '4.4', '4.2']
+		versionsARM: ['6.0', '5.0', '4.4', '4.2']
 	},
 	{
 		name: 'mysql',
@@ -418,16 +418,16 @@ export const supportedDatabaseTypesAndVersions = [
 		fancyName: 'MariaDB',
 		baseImage: 'bitnami/mariadb',
 		baseImageARM: 'mariadb',
-		versions: ['10.8', '10.7', '10.6', '10.5', '10.4', '10.3', '10.2'],
+		versions: ['10.11', '10.10', '10.9', '10.8', '10.7', '10.6', '10.5', '10.4', '10.3', '10.2'],
-		versionsARM: ['10.8', '10.7', '10.6', '10.5', '10.4', '10.3', '10.2']
+		versionsARM: ['10.11', '10.10', '10.9', '10.8', '10.7', '10.6', '10.5', '10.4', '10.3', '10.2']
 	},
 	{
 		name: 'postgresql',
 		fancyName: 'PostgreSQL',
 		baseImage: 'bitnami/postgresql',
 		baseImageARM: 'postgres',
-		versions: ['14.5.0', '13.8.0', '12.12.0', '11.17.0', '10.22.0'],
+		versions: ['15.2.0', '14.7.0', '14.5.0', '13.8.0', '12.12.0', '11.17.0', '10.22.0'],
-		versionsARM: ['14.5', '13.8', '12.12', '11.17', '10.22']
+		versionsARM: ['15.2', '14.7', '14.5', '13.8', '12.12', '11.17', '10.22']
 	},
 	{
 		name: 'redis',
@@ -442,14 +442,14 @@ export const supportedDatabaseTypesAndVersions = [
 		fancyName: 'CouchDB',
 		baseImage: 'bitnami/couchdb',
 		baseImageARM: 'couchdb',
-		versions: ['3.2.2', '3.1.2', '2.3.1'],
+		versions: ['3.3.1', '3.2.2', '3.1.2', '2.3.1'],
-		versionsARM: ['3.2.2', '3.1.2', '2.3.1']
+		versionsARM: ['3.3', '3.2.2', '3.1.2', '2.3.1']
 	},
 	{
 		name: 'edgedb',
 		fancyName: 'EdgeDB',
 		baseImage: 'edgedb/edgedb',
-		versions: ['latest', '2.1', '2.0', '1.4']
+		versions: ['latest', '2.9', '2.8', '2.7']
 	}
 ];
 
@@ -849,97 +849,97 @@ export function generatePassword({
 
 type DatabaseConfiguration =
 	| {
-		volume: string;
+			volume: string;
-		image: string;
+			image: string;
-		command?: string;
+			command?: string;
-		ulimits: Record<string, unknown>;
+			ulimits: Record<string, unknown>;
-		privatePort: number;
+			privatePort: number;
-		environmentVariables: {
+			environmentVariables: {
-			MYSQL_DATABASE: string;
+				MYSQL_DATABASE: string;
-			MYSQL_PASSWORD: string;
+				MYSQL_PASSWORD: string;
-			MYSQL_ROOT_USER: string;
+				MYSQL_ROOT_USER: string;
-			MYSQL_USER: string;
+				MYSQL_USER: string;
-			MYSQL_ROOT_PASSWORD: string;
+				MYSQL_ROOT_PASSWORD: string;
-		};
+			};
-	}
+	  }
 	| {
-		volume: string;
+			volume: string;
-		image: string;
+			image: string;
-		command?: string;
+			command?: string;
-		ulimits: Record<string, unknown>;
+			ulimits: Record<string, unknown>;
-		privatePort: number;
+			privatePort: number;
-		environmentVariables: {
+			environmentVariables: {
-			MONGO_INITDB_ROOT_USERNAME?: string;
+				MONGO_INITDB_ROOT_USERNAME?: string;
-			MONGO_INITDB_ROOT_PASSWORD?: string;
+				MONGO_INITDB_ROOT_PASSWORD?: string;
-			MONGODB_ROOT_USER?: string;
+				MONGODB_ROOT_USER?: string;
-			MONGODB_ROOT_PASSWORD?: string;
+				MONGODB_ROOT_PASSWORD?: string;
-		};
+			};
-	}
+	  }
 	| {
-		volume: string;
+			volume: string;
-		image: string;
+			image: string;
-		command?: string;
+			command?: string;
-		ulimits: Record<string, unknown>;
+			ulimits: Record<string, unknown>;
-		privatePort: number;
+			privatePort: number;
-		environmentVariables: {
+			environmentVariables: {
-			MARIADB_ROOT_USER: string;
+				MARIADB_ROOT_USER: string;
-			MARIADB_ROOT_PASSWORD: string;
+				MARIADB_ROOT_PASSWORD: string;
-			MARIADB_USER: string;
+				MARIADB_USER: string;
-			MARIADB_PASSWORD: string;
+				MARIADB_PASSWORD: string;
-			MARIADB_DATABASE: string;
+				MARIADB_DATABASE: string;
-		};
+			};
-	}
+	  }
 	| {
-		volume: string;
+			volume: string;
-		image: string;
+			image: string;
-		command?: string;
+			command?: string;
-		ulimits: Record<string, unknown>;
+			ulimits: Record<string, unknown>;
-		privatePort: number;
+			privatePort: number;
-		environmentVariables: {
+			environmentVariables: {
-			POSTGRES_PASSWORD?: string;
+				POSTGRES_PASSWORD?: string;
-			POSTGRES_USER?: string;
+				POSTGRES_USER?: string;
-			POSTGRES_DB?: string;
+				POSTGRES_DB?: string;
-			POSTGRESQL_POSTGRES_PASSWORD?: string;
+				POSTGRESQL_POSTGRES_PASSWORD?: string;
-			POSTGRESQL_USERNAME?: string;
+				POSTGRESQL_USERNAME?: string;
-			POSTGRESQL_PASSWORD?: string;
+				POSTGRESQL_PASSWORD?: string;
-			POSTGRESQL_DATABASE?: string;
+				POSTGRESQL_DATABASE?: string;
-		};
+			};
-	}
+	  }
 	| {
-		volume: string;
+			volume: string;
-		image: string;
+			image: string;
-		command?: string;
+			command?: string;
-		ulimits: Record<string, unknown>;
+			ulimits: Record<string, unknown>;
-		privatePort: number;
+			privatePort: number;
-		environmentVariables: {
+			environmentVariables: {
-			REDIS_AOF_ENABLED: string;
+				REDIS_AOF_ENABLED: string;
-			REDIS_PASSWORD: string;
+				REDIS_PASSWORD: string;
-		};
+			};
-	}
+	  }
 	| {
-		volume: string;
+			volume: string;
-		image: string;
+			image: string;
-		command?: string;
+			command?: string;
-		ulimits: Record<string, unknown>;
+			ulimits: Record<string, unknown>;
-		privatePort: number;
+			privatePort: number;
-		environmentVariables: {
+			environmentVariables: {
-			COUCHDB_PASSWORD: string;
+				COUCHDB_PASSWORD: string;
-			COUCHDB_USER: string;
+				COUCHDB_USER: string;
-		};
+			};
-	}
+	  }
 	| {
-		volume: string;
+			volume: string;
-		image: string;
+			image: string;
-		command?: string;
+			command?: string;
-		ulimits: Record<string, unknown>;
+			ulimits: Record<string, unknown>;
-		privatePort: number;
+			privatePort: number;
-		environmentVariables: {
+			environmentVariables: {
-			EDGEDB_SERVER_PASSWORD: string;
+				EDGEDB_SERVER_PASSWORD: string;
-			EDGEDB_SERVER_USER: string;
+				EDGEDB_SERVER_USER: string;
-			EDGEDB_SERVER_DATABASE: string;
+				EDGEDB_SERVER_DATABASE: string;
-			EDGEDB_SERVER_TLS_CERT_MODE: string;
+				EDGEDB_SERVER_TLS_CERT_MODE: string;
-		};
+			};
-	};
+	  };
 export function generateDatabaseConfiguration(database: any): DatabaseConfiguration {
 	const { id, dbUser, dbUserPassword, rootUser, rootUserPassword, defaultDatabase, version, type } =
 		database;
@@ -1013,7 +1013,7 @@ export function generateDatabaseConfiguration(database: any): DatabaseConfigurat
 			ulimits: {}
 		};
 		if (isARM()) {
-			configuration.volume = `${id}-${type}-data:/var/lib/postgresql`;
+			configuration.volume = `${id}-${type}-data:/var/lib/postgresql/data`;
 			configuration.environmentVariables = {
 				POSTGRES_PASSWORD: dbUserPassword,
 				POSTGRES_USER: dbUser,
@@ -1038,8 +1038,9 @@ export function generateDatabaseConfiguration(database: any): DatabaseConfigurat
 		};
 		if (isARM()) {
 			configuration.volume = `${id}-${type}-data:/data`;
-			configuration.command = `/usr/local/bin/redis-server --appendonly ${appendOnly ? 'yes' : 'no'
+			configuration.command = `/usr/local/bin/redis-server --appendonly ${
-				} --requirepass ${dbUserPassword}`;
+				appendOnly ? 'yes' : 'no'
+			} --requirepass ${dbUserPassword}`;
 		}
 		return configuration;
 	} else if (type === 'couchdb') {
@@ -1124,12 +1125,12 @@ export type ComposeFileService = {
 	command?: string;
 	ports?: string[];
 	build?:
-	| {
+		| {
-		context: string;
+				context: string;
-		dockerfile: string;
+				dockerfile: string;
-		args?: Record<string, unknown>;
+				args?: Record<string, unknown>;
-	}
+		  }
-	| string;
+		| string;
 	deploy?: {
 		restart_policy?: {
 			condition?: string;
@@ -1200,7 +1201,7 @@ export const createDirectories = async ({
 	let workdirFound = false;
 	try {
 		workdirFound = !!(await fs.stat(workdir));
-	} catch (error) { }
+	} catch (error) {}
 	if (workdirFound) {
 		await executeCommand({ command: `rm -fr ${workdir}` });
 	}
@@ -1727,7 +1728,7 @@ export async function stopBuild(buildId, applicationId) {
 					}
 				}
 				count++;
-			} catch (error) { }
+			} catch (error) {}
 		}, 100);
 	});
 }
@@ -1750,7 +1751,7 @@ export async function cleanupDockerStorage(dockerId) {
 	// Cleanup images that are not used by any container
 	try {
 		await executeCommand({ dockerId, command: `docker image prune -af` });
-	} catch (error) { }
+	} catch (error) {}
 
 	// Prune coolify managed containers
 	try {
@@ -1758,12 +1759,12 @@ export async function cleanupDockerStorage(dockerId) {
 			dockerId,
 			command: `docker container prune -f --filter "label=coolify.managed=true"`
 		});
-	} catch (error) { }
+	} catch (error) {}
 
 	// Cleanup build caches
 	try {
 		await executeCommand({ dockerId, command: `docker builder prune -af` });
-	} catch (error) { }
+	} catch (error) {}
 }
 
 export function persistentVolumes(id, persistentStorage, config) {

apps/api/src/routes/api/v1/databases/handlers.ts

@@ -302,7 +302,7 @@ export async function startDatabase(request: FastifyRequest<OnlyId>) {
 			databaseSecret
 		} = database;
 		const { privatePort, command, environmentVariables, image, volume, ulimits } =
-			generateDatabaseConfiguration(database, arch);
+			generateDatabaseConfiguration(database);
 
 		const network = destinationDockerId && destinationDocker.network;
 		const volumeName = volume.split(':')[0];

apps/api/src/routes/api/v1/destinations/handlers.ts

@@ -1,279 +1,353 @@
 import type { FastifyRequest } from 'fastify';
 import { FastifyReply } from 'fastify';
-import sshConfig from 'ssh-config'
+import {
-import fs from 'fs/promises'
+	errorHandler,
-import os from 'os';
+	executeCommand,
-
+	listSettings,
-import { createRemoteEngineConfiguration, decrypt, errorHandler, executeCommand, listSettings, prisma, startTraefikProxy, stopTraefikProxy } from '../../../../lib/common';
+	prisma,
+	startTraefikProxy,
+	stopTraefikProxy
+} from '../../../../lib/common';
 import { checkContainer } from '../../../../lib/docker';
 
 import type { OnlyId } from '../../../../types';
-import type { CheckDestination, ListDestinations, NewDestination, Proxy, SaveDestinationSettings } from './types';
+import type {
+	CheckDestination,
+	ListDestinations,
+	NewDestination,
+	Proxy,
+	SaveDestinationSettings
+} from './types';
 
 export async function listDestinations(request: FastifyRequest<ListDestinations>) {
-    try {
+	try {
-        const teamId = request.user.teamId;
+		const teamId = request.user.teamId;
-        const { onlyVerified = false } = request.query
+		const { onlyVerified = false } = request.query;
-        let destinations = []
+		let destinations = [];
-        if (teamId === '0') {
+		if (teamId === '0') {
-            destinations = await prisma.destinationDocker.findMany({ include: { teams: true } });
+			destinations = await prisma.destinationDocker.findMany({ include: { teams: true } });
-        } else {
+		} else {
-            destinations = await prisma.destinationDocker.findMany({
+			destinations = await prisma.destinationDocker.findMany({
-                where: { teams: { some: { id: teamId } } },
+				where: { teams: { some: { id: teamId } } },
-                include: { teams: true }
+				include: { teams: true }
-            });
+			});
-        }
+		}
-        if (onlyVerified) {
+		if (onlyVerified) {
-            destinations = destinations.filter(destination => destination.engine || (destination.remoteEngine && destination.remoteVerified))
+			destinations = destinations.filter(
-        }
+				(destination) =>
-        return {
+					destination.engine || (destination.remoteEngine && destination.remoteVerified)
-            destinations
+			);
-        }
+		}
-    } catch ({ status, message }) {
+		return {
-        return errorHandler({ status, message })
+			destinations
-    }
+		};
+	} catch ({ status, message }) {
+		return errorHandler({ status, message });
+	}
 }
 export async function checkDestination(request: FastifyRequest<CheckDestination>) {
-    try {
+	try {
-        const { network } = request.body;
+		const { network } = request.body;
-        const found = await prisma.destinationDocker.findFirst({ where: { network } });
+		const found = await prisma.destinationDocker.findFirst({ where: { network } });
-        if (found) {
+		if (found) {
-            throw {
+			throw {
-                message: `Network already exists: ${network}`
+				message: `Network already exists: ${network}`
-            };
+			};
-        }
+		}
-        return {}
+		return {};
-    } catch ({ status, message }) {
+	} catch ({ status, message }) {
-        return errorHandler({ status, message })
+		return errorHandler({ status, message });
-    }
+	}
 }
 export async function getDestination(request: FastifyRequest<OnlyId>) {
-    try {
+	try {
-        const { id } = request.params
+		const { id } = request.params;
-        const teamId = request.user?.teamId;
+		const teamId = request.user?.teamId;
-        const destination = await prisma.destinationDocker.findFirst({
+		const destination = await prisma.destinationDocker.findFirst({
-            where: { id, teams: { some: { id: teamId === '0' ? undefined : teamId } } },
+			where: { id, teams: { some: { id: teamId === '0' ? undefined : teamId } } },
-            include: { sshKey: true, application: true, service: true, database: true }
+			include: { sshKey: true, application: true, service: true, database: true }
-        });
+		});
-        if (!destination && id !== 'new') {
+		if (!destination && id !== 'new') {
-            throw { status: 404, message: `Destination not found.` };
+			throw { status: 404, message: `Destination not found.` };
-        }
+		}
-        const settings = await listSettings();
+		const settings = await listSettings();
-        const payload = {
+		const payload = {
-            destination,
+			destination,
-            settings
+			settings
-        };
+		};
-        return {
+		return {
-            ...payload
+			...payload
-        };
+		};
-
+	} catch ({ status, message }) {
-    } catch ({ status, message }) {
+		return errorHandler({ status, message });
-        return errorHandler({ status, message })
+	}
-    }
 }
 export async function newDestination(request: FastifyRequest<NewDestination>, reply: FastifyReply) {
-    try {
+	try {
-        const teamId = request.user.teamId;
+		const teamId = request.user.teamId;
-        const { id } = request.params
+		const { id } = request.params;
 
-        let { name, network, engine, isCoolifyProxyUsed, remoteIpAddress, remoteUser, remotePort } = request.body
+		let { name, network, engine, isCoolifyProxyUsed, remoteIpAddress, remoteUser, remotePort } =
-        if (id === 'new') {
+			request.body;
-            if (engine) {
+		if (id === 'new') {
-                const { stdout } = await await executeCommand({ command: `docker network ls --filter 'name=^${network}$' --format '{{json .}}'` });
+			if (engine) {
-                if (stdout === '') {
+				const { stdout } = await await executeCommand({
-                    await await executeCommand({ command: `docker network create --attachable ${network}` });
+					command: `docker network ls --filter 'name=^${network}$' --format '{{json .}}'`
-                }
+				});
-                await prisma.destinationDocker.create({
+				if (stdout === '') {
-                    data: { name, teams: { connect: { id: teamId } }, engine, network, isCoolifyProxyUsed }
+					await await executeCommand({ command: `docker network create --attachable ${network}` });
-                });
+				}
-                const destinations = await prisma.destinationDocker.findMany({ where: { engine } });
+				await prisma.destinationDocker.create({
-                const destination = destinations.find((destination) => destination.network === network);
+					data: { name, teams: { connect: { id: teamId } }, engine, network, isCoolifyProxyUsed }
-                if (destinations.length > 0) {
+				});
-                    const proxyConfigured = destinations.find(
+				const destinations = await prisma.destinationDocker.findMany({ where: { engine } });
-                        (destination) => destination.network !== network && destination.isCoolifyProxyUsed === true
+				const destination = destinations.find((destination) => destination.network === network);
-                    );
+				if (destinations.length > 0) {
-                    if (proxyConfigured) {
+					const proxyConfigured = destinations.find(
-                        isCoolifyProxyUsed = !!proxyConfigured.isCoolifyProxyUsed;
+						(destination) =>
-                    }
+							destination.network !== network && destination.isCoolifyProxyUsed === true
-                    await prisma.destinationDocker.updateMany({ where: { engine }, data: { isCoolifyProxyUsed } });
+					);
-                }
+					if (proxyConfigured) {
-                if (isCoolifyProxyUsed) {
+						isCoolifyProxyUsed = !!proxyConfigured.isCoolifyProxyUsed;
-                    await startTraefikProxy(destination.id);
+					}
-                }
+					await prisma.destinationDocker.updateMany({
-                return reply.code(201).send({ id: destination.id });
+						where: { engine },
-            } else {
+						data: { isCoolifyProxyUsed }
-                const destination = await prisma.destinationDocker.create({
+					});
-                    data: { name, teams: { connect: { id: teamId } }, engine, network, isCoolifyProxyUsed, remoteEngine: true, remoteIpAddress, remoteUser, remotePort: Number(remotePort) }
+				}
-                });
+				if (isCoolifyProxyUsed) {
-                return reply.code(201).send({ id: destination.id })
+					await startTraefikProxy(destination.id);
-            }
+				}
-        } else {
+				return reply.code(201).send({ id: destination.id });
-            await prisma.destinationDocker.update({ where: { id }, data: { name, engine, network } });
+			} else {
-            return reply.code(201).send();
+				const destination = await prisma.destinationDocker.create({
-        }
+					data: {
-
+						name,
-    } catch ({ status, message }) {
+						teams: { connect: { id: teamId } },
-        return errorHandler({ status, message })
+						engine,
-    }
+						network,
+						isCoolifyProxyUsed,
+						remoteEngine: true,
+						remoteIpAddress,
+						remoteUser,
+						remotePort: Number(remotePort)
+					}
+				});
+				return reply.code(201).send({ id: destination.id });
+			}
+		} else {
+			await prisma.destinationDocker.update({ where: { id }, data: { name, engine, network } });
+			return reply.code(201).send();
+		}
+	} catch ({ status, message }) {
+		return errorHandler({ status, message });
+	}
 }
 export async function deleteDestination(request: FastifyRequest<OnlyId>) {
-    try {
+	try {
-        const { id } = request.params
+		const { id } = request.params;
-        const { network, remoteVerified, engine, isCoolifyProxyUsed } = await prisma.destinationDocker.findUnique({ where: { id } });
+		const appFound = await prisma.application.findFirst({ where: { destinationDockerId: id } });
-        if (isCoolifyProxyUsed) {
+		const serviceFound = await prisma.service.findFirst({ where: { destinationDockerId: id } });
-            if (engine || remoteVerified) {
+		const databaseFound = await prisma.database.findFirst({ where: { destinationDockerId: id } });
-                const { stdout: found } = await executeCommand({
+		if (appFound || serviceFound || databaseFound) {
-                    dockerId: id,
+			throw {
-                    command: `docker ps -a --filter network=${network} --filter name=coolify-proxy --format '{{.}}'`
+				message: `Destination is in use.<br>Remove all applications, services and databases using this destination first.`
-                })
+			};
-                if (found) {
+		}
-                    await executeCommand({ dockerId: id, command: `docker network disconnect ${network} coolify-proxy` })
+		const { network, remoteVerified, engine, isCoolifyProxyUsed } =
-                    await executeCommand({ dockerId: id, command: `docker network rm ${network}` })
+			await prisma.destinationDocker.findUnique({ where: { id } });
-                }
+		if (isCoolifyProxyUsed) {
-            }
+			if (engine || remoteVerified) {
-        }
+				const { stdout: found } = await executeCommand({
-        await prisma.destinationDocker.delete({ where: { id } });
+					dockerId: id,
-        return {}
+					command: `docker ps -a --filter network=${network} --filter name=coolify-proxy --format '{{.}}'`
-    } catch ({ status, message }) {
+				});
-        return errorHandler({ status, message })
+				if (found) {
-    }
+					await executeCommand({
+						dockerId: id,
+						command: `docker network disconnect ${network} coolify-proxy`
+					});
+					await executeCommand({ dockerId: id, command: `docker network rm ${network}` });
+				}
+			}
+		}
+		await prisma.destinationDocker.delete({ where: { id } });
+		return {};
+	} catch ({ status, message }) {
+		return errorHandler({ status, message });
+	}
 }
 export async function saveDestinationSettings(request: FastifyRequest<SaveDestinationSettings>) {
-    try {
+	try {
-        const { engine, isCoolifyProxyUsed } = request.body;
+		const { engine, isCoolifyProxyUsed } = request.body;
-        await prisma.destinationDocker.updateMany({
+		await prisma.destinationDocker.updateMany({
-            where: { engine },
+			where: { engine },
-            data: { isCoolifyProxyUsed }
+			data: { isCoolifyProxyUsed }
-        });
+		});
 
-        return {
+		return {
-            status: 202
+			status: 202
-        }
+		};
-        // return reply.code(201).send();
+		// return reply.code(201).send();
-    } catch ({ status, message }) {
+	} catch ({ status, message }) {
-        return errorHandler({ status, message })
+		return errorHandler({ status, message });
-    }
+	}
 }
 export async function startProxy(request: FastifyRequest<Proxy>) {
-    const { id } = request.params
+	const { id } = request.params;
-    try {
+	try {
-        await startTraefikProxy(id);
+		await startTraefikProxy(id);
-        return {}
+		return {};
-    } catch ({ status, message }) {
+	} catch ({ status, message }) {
-        await stopTraefikProxy(id);
+		await stopTraefikProxy(id);
-        return errorHandler({ status, message })
+		return errorHandler({ status, message });
-    }
+	}
 }
 export async function stopProxy(request: FastifyRequest<Proxy>) {
-    const { id } = request.params
+	const { id } = request.params;
-    try {
+	try {
-        await stopTraefikProxy(id);
+		await stopTraefikProxy(id);
-        return {}
+		return {};
-    } catch ({ status, message }) {
+	} catch ({ status, message }) {
-        return errorHandler({ status, message })
+		return errorHandler({ status, message });
-    }
+	}
 }
 export async function restartProxy(request: FastifyRequest<Proxy>) {
-    const { id } = request.params
+	const { id } = request.params;
-    try {
+	try {
-        await stopTraefikProxy(id);
+		await stopTraefikProxy(id);
-        await startTraefikProxy(id);
+		await startTraefikProxy(id);
-        await prisma.destinationDocker.update({
+		await prisma.destinationDocker.update({
-            where: { id },
+			where: { id },
-            data: { isCoolifyProxyUsed: true }
+			data: { isCoolifyProxyUsed: true }
-        });
+		});
-        return {}
+		return {};
-    } catch ({ status, message }) {
+	} catch ({ status, message }) {
-        await prisma.destinationDocker.update({
+		await prisma.destinationDocker.update({
-            where: { id },
+			where: { id },
-            data: { isCoolifyProxyUsed: false }
+			data: { isCoolifyProxyUsed: false }
-        });
+		});
-        return errorHandler({ status, message })
+		return errorHandler({ status, message });
-    }
+	}
 }
 
 export async function assignSSHKey(request: FastifyRequest) {
-    try {
+	try {
-        const { id: sshKeyId } = request.body;
+		const { id: sshKeyId } = request.body;
-        const { id } = request.params;
+		const { id } = request.params;
-        await prisma.destinationDocker.update({ where: { id }, data: { sshKey: { connect: { id: sshKeyId } } } })
+		await prisma.destinationDocker.update({
-        return {}
+			where: { id },
-    } catch ({ status, message }) {
+			data: { sshKey: { connect: { id: sshKeyId } } }
-        return errorHandler({ status, message })
+		});
-    }
+		return {};
+	} catch ({ status, message }) {
+		return errorHandler({ status, message });
+	}
 }
 export async function verifyRemoteDockerEngineFn(id: string) {
-    const { remoteIpAddress, network, isCoolifyProxyUsed } = await prisma.destinationDocker.findFirst({ where: { id } })
+	const { remoteIpAddress, network, isCoolifyProxyUsed } = await prisma.destinationDocker.findFirst(
-    const daemonJson = `daemon-${id}.json`
+		{ where: { id } }
-    try {
+	);
-        await executeCommand({ sshCommand: true, command: `docker network inspect ${network}`, dockerId: id });
+	const daemonJson = `daemon-${id}.json`;
-    } catch (error) {
+	try {
-        await executeCommand({ command: `docker network create --attachable ${network}`, dockerId: id });
+		await executeCommand({
-    }
+			sshCommand: true,
+			command: `docker network inspect ${network}`,
+			dockerId: id
+		});
+	} catch (error) {
+		await executeCommand({
+			command: `docker network create --attachable ${network}`,
+			dockerId: id
+		});
+	}
 
-    try {
+	try {
-        await executeCommand({ sshCommand: true, command: `docker network inspect coolify-infra`, dockerId: id });
+		await executeCommand({
-    } catch (error) {
+			sshCommand: true,
-        await executeCommand({ command: `docker network create --attachable coolify-infra`, dockerId: id });
+			command: `docker network inspect coolify-infra`,
-    }
+			dockerId: id
+		});
+	} catch (error) {
+		await executeCommand({
+			command: `docker network create --attachable coolify-infra`,
+			dockerId: id
+		});
+	}
 
-    if (isCoolifyProxyUsed) await startTraefikProxy(id);
+	if (isCoolifyProxyUsed) await startTraefikProxy(id);
-    let isUpdated = false;
+	let isUpdated = false;
-    let daemonJsonParsed = {
+	let daemonJsonParsed = {
-        "live-restore": true,
+		'live-restore': true,
-        "features": {
+		features: {
-            "buildkit": true
+			buildkit: true
-        }
+		}
-    };
+	};
-    try {
+	try {
-        const { stdout: daemonJson } = await executeCommand({ sshCommand: true, dockerId: id, command: `cat /etc/docker/daemon.json` });
+		const { stdout: daemonJson } = await executeCommand({
-        daemonJsonParsed = JSON.parse(daemonJson);
+			sshCommand: true,
-        if (!daemonJsonParsed['live-restore'] || daemonJsonParsed['live-restore'] !== true) {
+			dockerId: id,
-            isUpdated = true;
+			command: `cat /etc/docker/daemon.json`
-            daemonJsonParsed['live-restore'] = true
+		});
-
+		daemonJsonParsed = JSON.parse(daemonJson);
-        }
+		if (!daemonJsonParsed['live-restore'] || daemonJsonParsed['live-restore'] !== true) {
-        if (!daemonJsonParsed?.features?.buildkit) {
+			isUpdated = true;
-            isUpdated = true;
+			daemonJsonParsed['live-restore'] = true;
-            daemonJsonParsed.features = {
+		}
-                buildkit: true
+		if (!daemonJsonParsed?.features?.buildkit) {
-            }
+			isUpdated = true;
-        }
+			daemonJsonParsed.features = {
-    } catch (error) {
+				buildkit: true
-        isUpdated = true;
+			};
-    }
+		}
-    try {
+	} catch (error) {
-        if (isUpdated) {
+		isUpdated = true;
-            await executeCommand({ shell: true, command: `echo '${JSON.stringify(daemonJsonParsed, null, 2)}' > /tmp/${daemonJson}` })
+	}
-            await executeCommand({ dockerId: id, command: `scp /tmp/${daemonJson} ${remoteIpAddress}-remote:/etc/docker/daemon.json` });
+	try {
-            await executeCommand({ command: `rm /tmp/${daemonJson}` })
+		if (isUpdated) {
-            await executeCommand({ sshCommand: true, dockerId: id, command: `systemctl restart docker` });
+			await executeCommand({
-        }
+				shell: true,
-        await prisma.destinationDocker.update({ where: { id }, data: { remoteVerified: true } })
+				command: `echo '${JSON.stringify(daemonJsonParsed, null, 2)}' > /tmp/${daemonJson}`
-    } catch (error) {
+			});
-        throw new Error('Error while verifying remote docker engine')
+			await executeCommand({
-    }
+				dockerId: id,
+				command: `scp /tmp/${daemonJson} ${remoteIpAddress}-remote:/etc/docker/daemon.json`
+			});
+			await executeCommand({ command: `rm /tmp/${daemonJson}` });
+			await executeCommand({ sshCommand: true, dockerId: id, command: `systemctl restart docker` });
+		}
+		await prisma.destinationDocker.update({ where: { id }, data: { remoteVerified: true } });
+	} catch (error) {
+		throw new Error('Error while verifying remote docker engine');
+	}
 }
-export async function verifyRemoteDockerEngine(request: FastifyRequest<OnlyId>, reply: FastifyReply) {
+export async function verifyRemoteDockerEngine(
-    const { id } = request.params;
+	request: FastifyRequest<OnlyId>,
-    try {
+	reply: FastifyReply
-        await verifyRemoteDockerEngineFn(id);
+) {
-        return reply.code(201).send()
+	const { id } = request.params;
-    } catch ({ status, message }) {
+	try {
-        await prisma.destinationDocker.update({ where: { id }, data: { remoteVerified: false } })
+		await verifyRemoteDockerEngineFn(id);
-        return errorHandler({ status, message })
+		return reply.code(201).send();
-    }
+	} catch ({ status, message }) {
+		await prisma.destinationDocker.update({ where: { id }, data: { remoteVerified: false } });
+		return errorHandler({ status, message });
+	}
 }
 
 export async function getDestinationStatus(request: FastifyRequest<OnlyId>) {
-    try {
+	try {
-        const { id } = request.params
+		const { id } = request.params;
-        const destination = await prisma.destinationDocker.findUnique({ where: { id } })
+		const destination = await prisma.destinationDocker.findUnique({ where: { id } });
-        const { found: isRunning } = await checkContainer({ dockerId: destination.id, container: 'coolify-proxy', remove: true })
+		const { found: isRunning } = await checkContainer({
-        return {
+			dockerId: destination.id,
-            isRunning
+			container: 'coolify-proxy',
-        }
+			remove: true
-    } catch ({ status, message }) {
+		});
-        return errorHandler({ status, message })
+		return {
-    }
+			isRunning
+		};
+	} catch ({ status, message }) {
+		return errorHandler({ status, message });
+	}
 }

apps/api/src/routes/api/v1/sources/handlers.ts

@@ -1,191 +1,231 @@
 import cuid from 'cuid';
 import type { FastifyRequest } from 'fastify';
-import { FastifyReply } from 'fastify';
 import { decrypt, encrypt, errorHandler, prisma } from '../../../../lib/common';
 import { OnlyId } from '../../../../types';
 import { CheckGitLabOAuthId, SaveGitHubSource, SaveGitLabSource } from './types';
 
 export async function listSources(request: FastifyRequest) {
-    try {
+	try {
-        const teamId = request.user?.teamId;
+		const teamId = request.user?.teamId;
-        const sources = await prisma.gitSource.findMany({
+		const sources = await prisma.gitSource.findMany({
-            where: { OR: [{ teams: { some: { id: teamId === "0" ? undefined : teamId } } }, { isSystemWide: true }] },
+			where: {
-            include: { teams: true, githubApp: true, gitlabApp: true }
+				OR: [
-        });
+					{ teams: { some: { id: teamId === '0' ? undefined : teamId } } },
-        return {
+					{ isSystemWide: true }
-            sources
+				]
-        }
+			},
-    } catch ({ status, message }) {
+			include: { teams: true, githubApp: true, gitlabApp: true }
-        return errorHandler({ status, message })
+		});
-    }
+		return {
+			sources
+		};
+	} catch ({ status, message }) {
+		return errorHandler({ status, message });
+	}
 }
 export async function saveSource(request, reply) {
-    try {
+	try {
-        const { id } = request.params
+		const { id } = request.params;
-        let { name, htmlUrl, apiUrl, customPort, customUser, isSystemWide } = request.body
+		let { name, htmlUrl, apiUrl, customPort, customUser, isSystemWide } = request.body;
-        if (customPort) customPort = Number(customPort)
+		if (customPort) customPort = Number(customPort);
-        await prisma.gitSource.update({
+		await prisma.gitSource.update({
-            where: { id },
+			where: { id },
-            data: { name, htmlUrl, apiUrl, customPort, customUser, isSystemWide }
+			data: { name, htmlUrl, apiUrl, customPort, customUser, isSystemWide }
-        });
+		});
-        return reply.code(201).send()
+		return reply.code(201).send();
-    } catch ({ status, message }) {
+	} catch ({ status, message }) {
-        return errorHandler({ status, message })
+		return errorHandler({ status, message });
-    }
+	}
 }
 export async function getSource(request: FastifyRequest<OnlyId>) {
-    try {
+	try {
-        const { id } = request.params
+		const { id } = request.params;
-        const { teamId } = request.user
+		const { teamId } = request.user;
-        const settings = await prisma.setting.findFirst({});
+		const settings = await prisma.setting.findFirst({});
 
-        if (id === 'new') {
+		if (id === 'new') {
-            return {
+			return {
-                source: {
+				source: {
-                    name: null,
+					name: null,
-                    type: null,
+					type: null,
-                    htmlUrl: null,
+					htmlUrl: null,
-                    apiUrl: null,
+					apiUrl: null,
-                    organization: null,
+					organization: null,
-                    customPort: 22,
+					customPort: 22,
-                    customUser: 'git',
+					customUser: 'git'
-                },
+				},
-                settings
+				settings
-            }
+			};
-        }
+		}
 
-        const source = await prisma.gitSource.findFirst({
+		const source = await prisma.gitSource.findFirst({
-            where: { id, OR: [{ teams: { some: { id: teamId === "0" ? undefined : teamId } } }, { isSystemWide: true }] },
+			where: {
-            include: { githubApp: true, gitlabApp: true }
+				id,
-        });
+				OR: [
-        if (!source) {
+					{ teams: { some: { id: teamId === '0' ? undefined : teamId } } },
-            throw { status: 404, message: 'Source not found.' }
+					{ isSystemWide: true }
-        }
+				]
+			},
+			include: { githubApp: true, gitlabApp: true }
+		});
+		if (!source) {
+			throw { status: 404, message: 'Source not found.' };
+		}
 
-        if (source?.githubApp?.clientSecret)
+		if (source?.githubApp?.clientSecret)
-            source.githubApp.clientSecret = decrypt(source.githubApp.clientSecret);
+			source.githubApp.clientSecret = decrypt(source.githubApp.clientSecret);
-        if (source?.githubApp?.webhookSecret)
+		if (source?.githubApp?.webhookSecret)
-            source.githubApp.webhookSecret = decrypt(source.githubApp.webhookSecret);
+			source.githubApp.webhookSecret = decrypt(source.githubApp.webhookSecret);
-        if (source?.githubApp?.privateKey) source.githubApp.privateKey = decrypt(source.githubApp.privateKey);
+		if (source?.githubApp?.privateKey)
-        if (source?.gitlabApp?.appSecret) source.gitlabApp.appSecret = decrypt(source.gitlabApp.appSecret);
+			source.githubApp.privateKey = decrypt(source.githubApp.privateKey);
+		if (source?.gitlabApp?.appSecret)
+			source.gitlabApp.appSecret = decrypt(source.gitlabApp.appSecret);
 
-        return {
+		return {
-            source,
+			source,
-            settings
+			settings
-        };
+		};
-
+	} catch ({ status, message }) {
-    } catch ({ status, message }) {
+		return errorHandler({ status, message });
-        return errorHandler({ status, message })
+	}
-    }
 }
 
 export async function deleteSource(request) {
-    try {
+	try {
-        const { id } = request.params
+		const { id } = request.params;
-        const source = await prisma.gitSource.delete({
+		const gitAppFound = await prisma.application.findFirst({ where: { gitSourceId: id } });
-            where: { id },
+		if (gitAppFound) {
-            include: { githubApp: true, gitlabApp: true }
+			throw {
-        });
+				status: 400,
-        if (source.githubAppId) {
+				message: 'This source is used by an application. Please remove the application first.'
-            await prisma.githubApp.delete({ where: { id: source.githubAppId } });
+			};
-        }
+		}
-        if (source.gitlabAppId) {
+		const source = await prisma.gitSource.delete({
-            await prisma.gitlabApp.delete({ where: { id: source.gitlabAppId } });
+			where: { id },
-        }
+			include: { githubApp: true, gitlabApp: true }
-        return {}
+		});
-    } catch ({ status, message }) {
+		if (source.githubAppId) {
-        return errorHandler({ status, message })
+			await prisma.githubApp.delete({ where: { id: source.githubAppId } });
-    }
+		}
-
+		if (source.gitlabAppId) {
+			await prisma.gitlabApp.delete({ where: { id: source.gitlabAppId } });
+		}
+		return {};
+	} catch ({ status, message }) {
+		return errorHandler({ status, message });
+	}
 }
 export async function saveGitHubSource(request: FastifyRequest<SaveGitHubSource>) {
-    try {
+	try {
-        const { teamId } = request.user
+		const { teamId } = request.user;
 
-        const { id } = request.params
+		const { id } = request.params;
-        let { name, htmlUrl, apiUrl, organization, customPort, isSystemWide } = request.body
+		let { name, htmlUrl, apiUrl, organization, customPort, isSystemWide } = request.body;
 
-        if (customPort) customPort = Number(customPort)
+		if (customPort) customPort = Number(customPort);
-        if (id === 'new') {
+		if (id === 'new') {
-            const newId = cuid()
+			const newId = cuid();
-            await prisma.gitSource.create({
+			await prisma.gitSource.create({
-                data: {
+				data: {
-                    id: newId,
+					id: newId,
-                    name,
+					name,
-                    htmlUrl,
+					htmlUrl,
-                    apiUrl,
+					apiUrl,
-                    organization,
+					organization,
-                    customPort,
+					customPort,
-                    isSystemWide,
+					isSystemWide,
-                    type: 'github',
+					type: 'github',
-                    teams: { connect: { id: teamId } }
+					teams: { connect: { id: teamId } }
-                }
+				}
-            });
+			});
-            return {
+			return {
-                id: newId
+				id: newId
-            }
+			};
-        }
+		}
-        throw { status: 500, message: 'Wrong request.' }
+		throw { status: 500, message: 'Wrong request.' };
-    } catch ({ status, message }) {
+	} catch ({ status, message }) {
-        return errorHandler({ status, message })
+		return errorHandler({ status, message });
-    }
+	}
 }
 export async function saveGitLabSource(request: FastifyRequest<SaveGitLabSource>) {
-    try {
+	try {
-        const { id } = request.params
+		const { id } = request.params;
-        const { teamId } = request.user
+		const { teamId } = request.user;
-        let { type, name, htmlUrl, apiUrl, oauthId, appId, appSecret, groupName, customPort, customUser } =
+		let {
-            request.body
+			type,
+			name,
+			htmlUrl,
+			apiUrl,
+			oauthId,
+			appId,
+			appSecret,
+			groupName,
+			customPort,
+			customUser
+		} = request.body;
 
-        if (oauthId) oauthId = Number(oauthId);
+		if (oauthId) oauthId = Number(oauthId);
-        if (customPort) customPort = Number(customPort)
+		if (customPort) customPort = Number(customPort);
-        const encryptedAppSecret = encrypt(appSecret);
+		const encryptedAppSecret = encrypt(appSecret);
 
-        if (id === 'new') {
+		if (id === 'new') {
-            const newId = cuid()
+			const newId = cuid();
-            await prisma.gitSource.create({ data: { id: newId, type, apiUrl, htmlUrl, name, customPort, customUser, teams: { connect: { id: teamId } } } });
+			await prisma.gitSource.create({
-            await prisma.gitlabApp.create({
+				data: {
-                data: {
+					id: newId,
-                    teams: { connect: { id: teamId } },
+					type,
-                    appId,
+					apiUrl,
-                    oauthId,
+					htmlUrl,
-                    groupName,
+					name,
-                    appSecret: encryptedAppSecret,
+					customPort,
-                    gitSource: { connect: { id: newId } }
+					customUser,
-                }
+					teams: { connect: { id: teamId } }
-            });
+				}
-            return {
+			});
-                status: 201,
+			await prisma.gitlabApp.create({
-                id: newId
+				data: {
-            }
+					teams: { connect: { id: teamId } },
-        } else {
+					appId,
-            await prisma.gitSource.update({ where: { id }, data: { type, apiUrl, htmlUrl, name, customPort, customUser } });
+					oauthId,
-            await prisma.gitlabApp.update({
+					groupName,
-                where: { id },
+					appSecret: encryptedAppSecret,
-                data: {
+					gitSource: { connect: { id: newId } }
-                    appId,
+				}
-                    oauthId,
+			});
-                    groupName,
+			return {
-                    appSecret: encryptedAppSecret,
+				status: 201,
-                }
+				id: newId
-            });
+			};
-        }
+		} else {
-        return { status: 201 };
+			await prisma.gitSource.update({
-
+				where: { id },
-    } catch ({ status, message }) {
+				data: { type, apiUrl, htmlUrl, name, customPort, customUser }
-        return errorHandler({ status, message })
+			});
-    }
+			await prisma.gitlabApp.update({
+				where: { id },
+				data: {
+					appId,
+					oauthId,
+					groupName,
+					appSecret: encryptedAppSecret
+				}
+			});
+		}
+		return { status: 201 };
+	} catch ({ status, message }) {
+		return errorHandler({ status, message });
+	}
 }
 
 export async function checkGitLabOAuthID(request: FastifyRequest<CheckGitLabOAuthId>) {
-    try {
+	try {
-        const { oauthId } = request.body
+		const { oauthId } = request.body;
-        const found = await prisma.gitlabApp.findFirst({ where: { oauthId: Number(oauthId) } });
+		const found = await prisma.gitlabApp.findFirst({ where: { oauthId: Number(oauthId) } });
-        if (found) {
+		if (found) {
-            throw { status: 500, message: 'OAuthID already configured in Coolify.' }
+			throw { status: 500, message: 'OAuthID already configured in Coolify.' };
-        }
+		}
-        return {}
+		return {};
-    } catch ({ status, message }) {
+	} catch ({ status, message }) {
-        return errorHandler({ status, message })
+		return errorHandler({ status, message });
-    }
+	}
 }

apps/api/src/routes/webhooks/traefik/handlers.ts

@@ -543,6 +543,9 @@ export async function proxyConfiguration(request: FastifyRequest<OnlyId>, remote
 							const template: any = await parseAndFindServiceTemplates(service, null, true);
 							const { proxy } = template.services[oneService] || found.services[oneService];
 							for (let configuration of proxy) {
+								if (configuration.hostPort) {
+									continue;
+								}
 								if (configuration.domain) {
 									const setting = serviceSetting.find(
 										(a) => a.variableName === configuration.domain

package.json

@@ -1,7 +1,7 @@
 {
   "name": "coolify",
   "description": "An open-source & self-hostable Heroku / Netlify alternative.",
-  "version": "3.12.28",
+  "version": "3.12.30",
   "license": "Apache-2.0",
   "repository": "github:coollabsio/coolify",
   "scripts": {