Docker compose support (#111)

* feat(WIP): compose implementation

* feat: add volumes, networks, services name hash generate

* feat: add compose config test unique

* feat: add tests for each unique config

* feat: implement lodash for docker compose parsing

* feat: add tests for generating compose file

* refactor: implement logs docker compose

* refactor: composeFile set not empty

* feat: implement providers for compose deployments

* feat: add Files volumes to compose

* feat: add stop compose button

* refactor: change strategie of building compose

* feat: create .env file in composepath

* refactor: simplify git and github function

* chore: update deps

* refactor: update migrations and add badge to recognize compose type

* chore: update lock yaml

* refactor: use code editor

* feat: add monitoring for app types

* refactor: reset stats on change appName

* refactor: add option to clean monitoring folder

* feat: show current command that will run

* feat: add prefix

* fix: add missing types

* refactor: add docker provider and expose by default as false

* refactor: customize error page

* refactor: unified deployments to be a single one

* feat: add vitest to ci/cd

* revert: back to initial version

* refactor: add maxconcurrency vitest

* refactor: add pool forks to vitest

* feat: add pocketbase template

* fix: update path resolution compose

* removed

* feat: add template pocketbase

* feat: add pocketbase template

* feat: add support button

* feat: add plausible template

* feat: add calcom template

* feat: add version to each template

* feat: add code editor to enviroment variables and swarm settings json

* refactor: add loader when download the image

* fix: use base64 to generate keys plausible

* feat: add recognized domain names by enviroment compose

* refactor: show alert to redeploy in each card advanced tab

* refactor: add validation to prevent create compose if not have permissions

* chore: add templates section to contributing

* chore: add example contributing

server/api/services/deployment.ts

@@ -2,12 +2,17 @@ import { existsSync, promises as fsPromises } from "node:fs";
 import path from "node:path";
 import { LOGS_PATH } from "@/server/constants";
 import { db } from "@/server/db";
-import { deployments } from "@/server/db/schema";
+import {
+	type apiCreateDeployment,
+	type apiCreateDeploymentCompose,
+	deployments,
+} from "@/server/db/schema";
 import { removeDirectoryIfExistsContent } from "@/server/utils/filesystem/directory";
 import { TRPCError } from "@trpc/server";
 import { format } from "date-fns";
 import { desc, eq } from "drizzle-orm";
 import { type Application, findApplicationById } from "./application";
+import { type Compose, findComposeById } from "./compose";
 
 export type Deployment = typeof deployments.$inferSelect;
 type CreateDeploymentInput = Omit<
@@ -31,7 +36,12 @@ export const findDeploymentById = async (applicationId: string) => {
 	return application;
 };
 
-export const createDeployment = async (deployment: CreateDeploymentInput) => {
+export const createDeployment = async (
+	deployment: Omit<
+		typeof apiCreateDeployment._type,
+		"deploymentId" | "createdAt" | "status" | "logPath"
+	>,
+) => {
 	try {
 		const application = await findApplicationById(deployment.applicationId);
 
@@ -68,6 +78,48 @@ export const createDeployment = async (deployment: CreateDeploymentInput) => {
 	}
 };
 
+export const createDeploymentCompose = async (
+	deployment: Omit<
+		typeof apiCreateDeploymentCompose._type,
+		"deploymentId" | "createdAt" | "status" | "logPath"
+	>,
+) => {
+	try {
+		const compose = await findComposeById(deployment.composeId);
+
+		await removeLastTenComposeDeployments(deployment.composeId);
+		const formattedDateTime = format(new Date(), "yyyy-MM-dd:HH:mm:ss");
+		const fileName = `${compose.appName}-${formattedDateTime}.log`;
+		const logFilePath = path.join(LOGS_PATH, compose.appName, fileName);
+		await fsPromises.mkdir(path.join(LOGS_PATH, compose.appName), {
+			recursive: true,
+		});
+		await fsPromises.writeFile(logFilePath, "Initializing deployment");
+		const deploymentCreate = await db
+			.insert(deployments)
+			.values({
+				composeId: deployment.composeId,
+				title: deployment.title || "Deployment",
+				status: "running",
+				logPath: logFilePath,
+			})
+			.returning();
+		if (deploymentCreate.length === 0 || !deploymentCreate[0]) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: "Error to create the deployment",
+			});
+		}
+		return deploymentCreate[0];
+	} catch (error) {
+		console.log(error);
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Error to create the deployment",
+		});
+	}
+};
+
 export const removeDeployment = async (deploymentId: string) => {
 	try {
 		const deployment = await db
@@ -109,6 +161,23 @@ const removeLastTenDeployments = async (applicationId: string) => {
 	}
 };
 
+const removeLastTenComposeDeployments = async (composeId: string) => {
+	const deploymentList = await db.query.deployments.findMany({
+		where: eq(deployments.composeId, composeId),
+		orderBy: desc(deployments.createdAt),
+	});
+	if (deploymentList.length > 10) {
+		const deploymentsToDelete = deploymentList.slice(10);
+		for (const oldDeployment of deploymentsToDelete) {
+			const logPath = path.join(oldDeployment.logPath);
+			if (existsSync(logPath)) {
+				await fsPromises.unlink(logPath);
+			}
+			await removeDeployment(oldDeployment.deploymentId);
+		}
+	}
+};
+
 export const removeDeployments = async (application: Application) => {
 	const { appName, applicationId } = application;
 	const logsPath = path.join(LOGS_PATH, appName);
@@ -116,6 +185,16 @@ export const removeDeployments = async (application: Application) => {
 	await removeDeploymentsByApplicationId(applicationId);
 };
 
+export const removeDeploymentsByComposeId = async (compose: Compose) => {
+	const { appName } = compose;
+	const logsPath = path.join(LOGS_PATH, appName);
+	await removeDirectoryIfExistsContent(logsPath);
+	await db
+		.delete(deployments)
+		.where(eq(deployments.composeId, compose.composeId))
+		.returning();
+};
+
 export const findAllDeploymentsByApplicationId = async (
 	applicationId: string,
 ) => {
@@ -126,6 +205,14 @@ export const findAllDeploymentsByApplicationId = async (
 	return deploymentsList;
 };
 
+export const findAllDeploymentsByComposeId = async (composeId: string) => {
+	const deploymentsList = await db.query.deployments.findMany({
+		where: eq(deployments.composeId, composeId),
+		orderBy: desc(deployments.createdAt),
+	});
+	return deploymentsList;
+};
+
 export const updateDeployment = async (
 	deploymentId: string,
 	deploymentData: Partial<Deployment>,