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/utils/builders/compose.ts

@@ -0,0 +1,117 @@
+import {
+	createWriteStream,
+	existsSync,
+	mkdirSync,
+	writeFileSync,
+} from "node:fs";
+import type { InferResultType } from "@/server/types/with";
+import { spawnAsync } from "../process/spawnAsync";
+import { COMPOSE_PATH } from "@/server/constants";
+import { dirname, join } from "node:path";
+import {
+	generateFileMountsCompose,
+	prepareEnvironmentVariables,
+} from "../docker/utils";
+import boxen from "boxen";
+
+export type ComposeNested = InferResultType<
+	"compose",
+	{ project: true; mounts: true }
+>;
+export const buildCompose = async (compose: ComposeNested, logPath: string) => {
+	const writeStream = createWriteStream(logPath, { flags: "a" });
+	const { sourceType, appName, mounts, composeType, env, composePath } =
+		compose;
+	try {
+		const command = createCommand(compose);
+		generateFileMountsCompose(appName, mounts);
+
+		createEnvFile(compose);
+
+		const logContent = `
+App Name: ${appName}
+Build Compose 🐳
+Detected: ${mounts.length} mounts 📂
+Command: docker ${command}
+Source Type: docker ${sourceType} ✅
+Compose Type: ${composeType} ✅`;
+		const logBox = boxen(logContent, {
+			padding: {
+				left: 1,
+				right: 1,
+				bottom: 1,
+			},
+			width: 80,
+			borderStyle: "double",
+		});
+		writeStream.write(`\n${logBox}\n`);
+
+		const projectPath = join(COMPOSE_PATH, compose.appName);
+		await spawnAsync(
+			"docker",
+			[...command.split(" ")],
+			(data) => {
+				if (writeStream.writable) {
+					writeStream.write(data.toString());
+				}
+			},
+			{
+				cwd: projectPath,
+			},
+		);
+
+		writeStream.write("Docker Compose Deployed: ✅");
+	} catch (error) {
+		writeStream.write(`ERROR: ${error}: ❌`);
+		throw error;
+	} finally {
+		writeStream.end();
+	}
+};
+
+const sanitizeCommand = (command: string) => {
+	const sanitizedCommand = command.trim();
+
+	const parts = sanitizedCommand.split(/\s+/);
+
+	const restCommand = parts.map((arg) => arg.replace(/^"(.*)"$/, "$1"));
+
+	return restCommand.join(" ");
+};
+
+export const createCommand = (compose: ComposeNested) => {
+	const { composeType, appName, sourceType } = compose;
+
+	const path =
+		sourceType === "raw" ? "docker-compose.yml" : compose.composePath;
+	let command = "";
+
+	if (composeType === "docker-compose") {
+		command = `compose -p ${appName} -f ${path} up -d --build --remove-orphans`;
+	} else if (composeType === "stack") {
+		command = `stack deploy -c ${path} ${appName} --prune`;
+	}
+
+	const customCommand = sanitizeCommand(compose.command);
+
+	if (customCommand) {
+		command = `${command} ${customCommand}`;
+	}
+
+	return command;
+};
+
+const createEnvFile = (compose: ComposeNested) => {
+	const { env, composePath, appName } = compose;
+	const composeFilePath =
+		join(COMPOSE_PATH, appName, composePath) ||
+		join(COMPOSE_PATH, appName, "docker-compose.yml");
+
+	const envFilePath = join(dirname(composeFilePath), ".env");
+	const envFileContent = prepareEnvironmentVariables(env).join("\n");
+
+	if (!existsSync(dirname(envFilePath))) {
+		mkdirSync(dirname(envFilePath), { recursive: true });
+	}
+	writeFileSync(envFilePath, envFileContent);
+};

server/utils/docker/compose.ts

@@ -0,0 +1,45 @@
+import crypto from "node:crypto";
+import type { ComposeSpecification } from "./types";
+import { findComposeById } from "@/server/api/services/compose";
+import { dump, load } from "js-yaml";
+import { addPrefixToAllVolumes } from "./compose/volume";
+import { addPrefixToAllConfigs } from "./compose/configs";
+import { addPrefixToAllNetworks } from "./compose/network";
+import { addPrefixToAllSecrets } from "./compose/secrets";
+import { addPrefixToAllServiceNames } from "./compose/service";
+
+export const generateRandomHash = (): string => {
+	return crypto.randomBytes(4).toString("hex");
+};
+
+export const randomizeComposeFile = async (
+	composeId: string,
+	prefix?: string,
+) => {
+	const compose = await findComposeById(composeId);
+	const composeFile = compose.composeFile;
+	const composeData = load(composeFile) as ComposeSpecification;
+
+	const randomPrefix = prefix || generateRandomHash();
+
+	const newComposeFile = addPrefixToAllProperties(composeData, randomPrefix);
+
+	return dump(newComposeFile);
+};
+
+export const addPrefixToAllProperties = (
+	composeData: ComposeSpecification,
+	prefix: string,
+): ComposeSpecification => {
+	let updatedComposeData = { ...composeData };
+
+	updatedComposeData = addPrefixToAllServiceNames(updatedComposeData, prefix);
+
+	updatedComposeData = addPrefixToAllVolumes(updatedComposeData, prefix);
+
+	updatedComposeData = addPrefixToAllNetworks(updatedComposeData, prefix);
+	updatedComposeData = addPrefixToAllConfigs(updatedComposeData, prefix);
+
+	updatedComposeData = addPrefixToAllSecrets(updatedComposeData, prefix);
+	return updatedComposeData;
+};

server/utils/docker/compose/configs.ts

@@ -0,0 +1,73 @@
+import _ from "lodash";
+import type {
+	ComposeSpecification,
+	DefinitionsConfig,
+	DefinitionsService,
+} from "../types";
+
+export const addPrefixToConfigsRoot = (
+	configs: { [key: string]: DefinitionsConfig },
+	prefix: string,
+): { [key: string]: DefinitionsConfig } => {
+	const newConfigs: { [key: string]: DefinitionsConfig } = {};
+
+	_.forEach(configs, (config, configName) => {
+		const newConfigName = `${configName}-${prefix}`;
+		newConfigs[newConfigName] = _.cloneDeep(config);
+	});
+
+	return newConfigs;
+};
+
+export const addPrefixToConfigsInServices = (
+	services: { [key: string]: DefinitionsService },
+	prefix: string,
+): { [key: string]: DefinitionsService } => {
+	const newServices: { [key: string]: DefinitionsService } = {};
+
+	_.forEach(services, (serviceConfig, serviceName) => {
+		const newServiceConfig = _.cloneDeep(serviceConfig);
+
+		// Reemplazar nombres de configs en configs
+		if (_.has(newServiceConfig, "configs")) {
+			newServiceConfig.configs = _.map(newServiceConfig.configs, (config) => {
+				if (_.isString(config)) {
+					return `${config}-${prefix}`;
+				}
+				if (_.isObject(config) && config.source) {
+					return {
+						...config,
+						source: `${config.source}-${prefix}`,
+					};
+				}
+				return config;
+			});
+		}
+
+		newServices[serviceName] = newServiceConfig;
+	});
+
+	return newServices;
+};
+
+export const addPrefixToAllConfigs = (
+	composeData: ComposeSpecification,
+	prefix: string,
+): ComposeSpecification => {
+	const updatedComposeData = { ...composeData };
+	if (composeData?.configs) {
+		updatedComposeData.configs = addPrefixToConfigsRoot(
+			composeData.configs,
+			prefix,
+		);
+	}
+
+	if (composeData?.services) {
+		updatedComposeData.services = addPrefixToConfigsInServices(
+			composeData.services,
+			prefix,
+		);
+	}
+
+	return updatedComposeData;
+};

server/utils/docker/compose/network.ts

@@ -0,0 +1,72 @@
+import _ from "lodash";
+import type {
+	ComposeSpecification,
+	DefinitionsNetwork,
+	DefinitionsService,
+} from "../types";
+
+export const addPrefixToNetworksRoot = (
+	networks: { [key: string]: DefinitionsNetwork },
+	prefix: string,
+): { [key: string]: DefinitionsNetwork } => {
+	return _.mapKeys(networks, (_value, key) => `${key}-${prefix}`);
+};
+
+export const addPrefixToServiceNetworks = (
+	services: { [key: string]: DefinitionsService },
+	prefix: string,
+): { [key: string]: DefinitionsService } => {
+	return _.mapValues(services, (service) => {
+		if (service.networks) {
+			// 1 Case the most common
+			if (Array.isArray(service.networks)) {
+				service.networks = service.networks.map(
+					(network: string) => `${network}-${prefix}`,
+				);
+			} else {
+				// 2 Case
+				service.networks = _.mapKeys(
+					service.networks,
+					(_value, key) => `${key}-${prefix}`,
+				);
+
+				// 3 Case
+				service.networks = _.mapValues(service.networks, (value) => {
+					if (value && typeof value === "object") {
+						return _.mapKeys(value, (_val, innerKey) => {
+							if (innerKey === "aliases") {
+								return "aliases";
+							}
+							return `${innerKey}-${prefix}`;
+						});
+					}
+					return value;
+				});
+			}
+		}
+		return service;
+	});
+};
+
+export const addPrefixToAllNetworks = (
+	composeData: ComposeSpecification,
+	prefix: string,
+): ComposeSpecification => {
+	const updatedComposeData = { ...composeData };
+
+	if (updatedComposeData.networks) {
+		updatedComposeData.networks = addPrefixToNetworksRoot(
+			updatedComposeData.networks,
+			prefix,
+		);
+	}
+
+	if (updatedComposeData.services) {
+		updatedComposeData.services = addPrefixToServiceNetworks(
+			updatedComposeData.services,
+			prefix,
+		);
+	}
+
+	return updatedComposeData;
+};

server/utils/docker/compose/secrets.ts

@@ -0,0 +1,68 @@
+import _ from "lodash";
+import type { ComposeSpecification, DefinitionsService } from "../types";
+
+export const addPrefixToSecretsRoot = (
+	secrets: ComposeSpecification["secrets"],
+	prefix: string,
+): ComposeSpecification["secrets"] => {
+	const newSecrets: ComposeSpecification["secrets"] = {};
+	_.forEach(secrets, (secretConfig, secretName) => {
+		const newSecretName = `${secretName}-${prefix}`;
+		newSecrets[newSecretName] = _.cloneDeep(secretConfig);
+	});
+	return newSecrets;
+};
+
+export const addPrefixToSecretsInServices = (
+	services: { [key: string]: DefinitionsService },
+	prefix: string,
+): { [key: string]: DefinitionsService } => {
+	const newServices: { [key: string]: DefinitionsService } = {};
+
+	_.forEach(services, (serviceConfig, serviceName) => {
+		const newServiceConfig = _.cloneDeep(serviceConfig);
+
+		// Replace secret names in secrets
+		if (_.has(newServiceConfig, "secrets")) {
+			newServiceConfig.secrets = _.map(newServiceConfig.secrets, (secret) => {
+				if (_.isString(secret)) {
+					return `${secret}-${prefix}`;
+				}
+				if (_.isObject(secret) && secret.source) {
+					return {
+						...secret,
+						source: `${secret.source}-${prefix}`,
+					};
+				}
+				return secret;
+			});
+		}
+
+		newServices[serviceName] = newServiceConfig;
+	});
+
+	return newServices;
+};
+
+export const addPrefixToAllSecrets = (
+	composeData: ComposeSpecification,
+	prefix: string,
+): ComposeSpecification => {
+	const updatedComposeData = { ...composeData };
+
+	if (composeData?.secrets) {
+		updatedComposeData.secrets = addPrefixToSecretsRoot(
+			composeData.secrets,
+			prefix,
+		);
+	}
+
+	if (composeData?.services) {
+		updatedComposeData.services = addPrefixToSecretsInServices(
+			composeData.services,
+			prefix,
+		);
+	}
+
+	return updatedComposeData;
+};

server/utils/docker/compose/service.ts

@@ -0,0 +1,90 @@
+// En la sección depends_on de otros servicios: Para definir dependencias entre servicios.
+// En la sección networks de otros servicios: Aunque esto no es común, es posible referenciar servicios en redes personalizadas.
+// En la sección volumes_from de otros servicios: Para reutilizar volúmenes definidos por otro servicio.
+// En la sección links de otros servicios: Para crear enlaces entre servicios.
+// En la sección extends de otros servicios: Para extender la configuración de otro servicio.
+
+import _ from "lodash";
+import type { ComposeSpecification, DefinitionsService } from "../types";
+type DependsOnObject = NonNullable<
+	Exclude<DefinitionsService["depends_on"], string[]> extends infer T
+		? { [K in keyof T]: T[K] }
+		: never
+>;
+
+export const addPrefixToServiceNames = (
+	services: { [key: string]: DefinitionsService },
+	prefix: string,
+): { [key: string]: DefinitionsService } => {
+	const newServices: { [key: string]: DefinitionsService } = {};
+
+	for (const [serviceName, serviceConfig] of Object.entries(services)) {
+		const newServiceName = `${serviceName}-${prefix}`;
+		const newServiceConfig = _.cloneDeep(serviceConfig);
+
+		// Reemplazar nombres de servicios en depends_on
+		if (newServiceConfig.depends_on) {
+			if (Array.isArray(newServiceConfig.depends_on)) {
+				newServiceConfig.depends_on = newServiceConfig.depends_on.map(
+					(dep) => `${dep}-${prefix}`,
+				);
+			} else {
+				const newDependsOn: DependsOnObject = {};
+				for (const [depName, depConfig] of Object.entries(
+					newServiceConfig.depends_on,
+				)) {
+					newDependsOn[`${depName}-${prefix}`] = depConfig;
+				}
+				newServiceConfig.depends_on = newDependsOn;
+			}
+		}
+
+		// Reemplazar nombre en container_name
+		if (newServiceConfig.container_name) {
+			newServiceConfig.container_name = `${newServiceConfig.container_name}-${prefix}`;
+		}
+
+		// Reemplazar nombres de servicios en links
+		if (newServiceConfig.links) {
+			newServiceConfig.links = newServiceConfig.links.map(
+				(link) => `${link}-${prefix}`,
+			);
+		}
+
+		// Reemplazar nombres de servicios en extends
+		if (newServiceConfig.extends) {
+			if (typeof newServiceConfig.extends === "string") {
+				newServiceConfig.extends = `${newServiceConfig.extends}-${prefix}`;
+			} else {
+				newServiceConfig.extends.service = `${newServiceConfig.extends.service}-${prefix}`;
+			}
+		}
+
+		// Reemplazar nombres de servicios en volumes_from
+		if (newServiceConfig.volumes_from) {
+			newServiceConfig.volumes_from = newServiceConfig.volumes_from.map(
+				(vol) => `${vol}-${prefix}`,
+			);
+		}
+
+		newServices[newServiceName] = newServiceConfig;
+	}
+
+	return newServices;
+};
+
+export const addPrefixToAllServiceNames = (
+	composeData: ComposeSpecification,
+	prefix: string,
+): ComposeSpecification => {
+	const updatedComposeData = { ...composeData };
+
+	if (updatedComposeData.services) {
+		updatedComposeData.services = addPrefixToServiceNames(
+			updatedComposeData.services,
+			prefix,
+		);
+	}
+
+	return updatedComposeData;
+};

server/utils/docker/compose/volume.ts

@@ -0,0 +1,78 @@
+import _ from "lodash";
+import type {
+	ComposeSpecification,
+	DefinitionsService,
+	DefinitionsVolume,
+} from "../types";
+
+// Función para agregar prefijo a volúmenes
+export const addPrefixToVolumesRoot = (
+	volumes: { [key: string]: DefinitionsVolume },
+	prefix: string,
+): { [key: string]: DefinitionsVolume } => {
+	return _.mapKeys(volumes, (_value, key) => `${key}-${prefix}`);
+};
+
+export const addPrefixToVolumesInServices = (
+	services: { [key: string]: DefinitionsService },
+	prefix: string,
+): { [key: string]: DefinitionsService } => {
+	const newServices: { [key: string]: DefinitionsService } = {};
+
+	_.forEach(services, (serviceConfig, serviceName) => {
+		const newServiceConfig = _.cloneDeep(serviceConfig);
+
+		// Reemplazar nombres de volúmenes en volumes
+		if (_.has(newServiceConfig, "volumes")) {
+			newServiceConfig.volumes = _.map(newServiceConfig.volumes, (volume) => {
+				if (_.isString(volume)) {
+					const [volumeName, path] = volume.split(":");
+
+					// skip bind mounts and variables (e.g. $PWD)
+					if (
+						volumeName?.startsWith(".") ||
+						volumeName?.startsWith("/") ||
+						volumeName?.startsWith("$")
+					) {
+						return volume;
+					}
+					return `${volumeName}-${prefix}:${path}`;
+				}
+				if (_.isObject(volume) && volume.type === "volume" && volume.source) {
+					return {
+						...volume,
+						source: `${volume.source}-${prefix}`,
+					};
+				}
+				return volume;
+			});
+		}
+
+		newServices[serviceName] = newServiceConfig;
+	});
+
+	return newServices;
+};
+
+export const addPrefixToAllVolumes = (
+	composeData: ComposeSpecification,
+	prefix: string,
+): ComposeSpecification => {
+	const updatedComposeData = { ...composeData };
+
+	if (updatedComposeData.volumes) {
+		updatedComposeData.volumes = addPrefixToVolumesRoot(
+			updatedComposeData.volumes,
+			prefix,
+		);
+	}
+
+	if (updatedComposeData.services) {
+		updatedComposeData.services = addPrefixToVolumesInServices(
+			updatedComposeData.services,
+			prefix,
+		);
+	}
+
+	return updatedComposeData;
+};

server/utils/docker/types.ts

@@ -0,0 +1,879 @@
+export type DefinitionsInclude =
+	| string
+	| {
+			path?: StringOrList;
+			env_file?: StringOrList;
+			project_directory?: string;
+	  };
+export type StringOrList = string | ListOfStrings;
+export type ListOfStrings = string[];
+export type DefinitionsDevelopment = {
+	watch?: {
+		ignore?: string[];
+		path: string;
+		action: "rebuild" | "sync" | "sync+restart";
+		target?: string;
+		[k: string]: unknown;
+	}[];
+	[k: string]: unknown;
+} & Development;
+export type Development = {
+	watch?: {
+		ignore?: string[];
+		path: string;
+		action: "rebuild" | "sync" | "sync+restart";
+		target?: string;
+		[k: string]: unknown;
+	}[];
+	[k: string]: unknown;
+} | null;
+export type DefinitionsDeployment = {
+	mode?: string;
+	endpoint_mode?: string;
+	replicas?: number;
+	labels?: ListOrDict;
+	rollback_config?: {
+		parallelism?: number;
+		delay?: string;
+		failure_action?: string;
+		monitor?: string;
+		max_failure_ratio?: number;
+		order?: "start-first" | "stop-first";
+		/**
+		 * This interface was referenced by `undefined`'s JSON-Schema definition
+		 * via the `patternProperty` "^x-".
+		 */
+		[k: string]: unknown;
+	};
+	update_config?: {
+		parallelism?: number;
+		delay?: string;
+		failure_action?: string;
+		monitor?: string;
+		max_failure_ratio?: number;
+		order?: "start-first" | "stop-first";
+		/**
+		 * This interface was referenced by `undefined`'s JSON-Schema definition
+		 * via the `patternProperty` "^x-".
+		 */
+		[k: string]: unknown;
+	};
+	resources?: {
+		limits?: {
+			cpus?: number | string;
+			memory?: string;
+			pids?: number;
+			/**
+			 * This interface was referenced by `undefined`'s JSON-Schema definition
+			 * via the `patternProperty` "^x-".
+			 */
+			[k: string]: unknown;
+		};
+		reservations?: {
+			cpus?: number | string;
+			memory?: string;
+			generic_resources?: DefinitionsGenericResources;
+			devices?: DefinitionsDevices;
+			/**
+			 * This interface was referenced by `undefined`'s JSON-Schema definition
+			 * via the `patternProperty` "^x-".
+			 */
+			[k: string]: unknown;
+		};
+		/**
+		 * This interface was referenced by `undefined`'s JSON-Schema definition
+		 * via the `patternProperty` "^x-".
+		 */
+		[k: string]: unknown;
+	};
+	restart_policy?: {
+		condition?: string;
+		delay?: string;
+		max_attempts?: number;
+		window?: string;
+		/**
+		 * This interface was referenced by `undefined`'s JSON-Schema definition
+		 * via the `patternProperty` "^x-".
+		 */
+		[k: string]: unknown;
+	};
+	placement?: {
+		constraints?: string[];
+		preferences?: {
+			spread?: string;
+			/**
+			 * This interface was referenced by `undefined`'s JSON-Schema definition
+			 * via the `patternProperty` "^x-".
+			 */
+			[k: string]: unknown;
+		}[];
+		max_replicas_per_node?: number;
+		/**
+		 * This interface was referenced by `undefined`'s JSON-Schema definition
+		 * via the `patternProperty` "^x-".
+		 */
+		[k: string]: unknown;
+	};
+	/**
+	 * This interface was referenced by `undefined`'s JSON-Schema definition
+	 * via the `patternProperty` "^x-".
+	 *
+	 * This interface was referenced by `undefined`'s JSON-Schema definition
+	 * via the `patternProperty` "^x-".
+	 */
+	[k: string]: unknown;
+} & Deployment;
+export type ListOrDict =
+	| {
+			/**
+			 * This interface was referenced by `undefined`'s JSON-Schema definition
+			 * via the `patternProperty` ".+".
+			 */
+			[k: string]: string | number | boolean | null;
+	  }
+	| string[];
+export type DefinitionsGenericResources = {
+	discrete_resource_spec?: {
+		kind?: string;
+		value?: number;
+		/**
+		 * This interface was referenced by `undefined`'s JSON-Schema definition
+		 * via the `patternProperty` "^x-".
+		 */
+		[k: string]: unknown;
+	};
+	/**
+	 * This interface was referenced by `undefined`'s JSON-Schema definition
+	 * via the `patternProperty` "^x-".
+	 */
+	[k: string]: unknown;
+}[];
+export type DefinitionsDevices = {
+	capabilities?: ListOfStrings;
+	count?: string | number;
+	device_ids?: ListOfStrings;
+	driver?: string;
+	options?: ListOrDict;
+	/**
+	 * This interface was referenced by `undefined`'s JSON-Schema definition
+	 * via the `patternProperty` "^x-".
+	 */
+	[k: string]: unknown;
+}[];
+export type Deployment = {
+	mode?: string;
+	endpoint_mode?: string;
+	replicas?: number;
+	labels?: ListOrDict;
+	rollback_config?: {
+		parallelism?: number;
+		delay?: string;
+		failure_action?: string;
+		monitor?: string;
+		max_failure_ratio?: number;
+		order?: "start-first" | "stop-first";
+		/**
+		 * This interface was referenced by `undefined`'s JSON-Schema definition
+		 * via the `patternProperty` "^x-".
+		 */
+		[k: string]: unknown;
+	};
+	update_config?: {
+		parallelism?: number;
+		delay?: string;
+		failure_action?: string;
+		monitor?: string;
+		max_failure_ratio?: number;
+		order?: "start-first" | "stop-first";
+		/**
+		 * This interface was referenced by `undefined`'s JSON-Schema definition
+		 * via the `patternProperty` "^x-".
+		 */
+		[k: string]: unknown;
+	};
+	resources?: {
+		limits?: {
+			cpus?: number | string;
+			memory?: string;
+			pids?: number;
+			/**
+			 * This interface was referenced by `undefined`'s JSON-Schema definition
+			 * via the `patternProperty` "^x-".
+			 */
+			[k: string]: unknown;
+		};
+		reservations?: {
+			cpus?: number | string;
+			memory?: string;
+			generic_resources?: DefinitionsGenericResources;
+			devices?: DefinitionsDevices;
+			/**
+			 * This interface was referenced by `undefined`'s JSON-Schema definition
+			 * via the `patternProperty` "^x-".
+			 */
+			[k: string]: unknown;
+		};
+		/**
+		 * This interface was referenced by `undefined`'s JSON-Schema definition
+		 * via the `patternProperty` "^x-".
+		 */
+		[k: string]: unknown;
+	};
+	restart_policy?: {
+		condition?: string;
+		delay?: string;
+		max_attempts?: number;
+		window?: string;
+		/**
+		 * This interface was referenced by `undefined`'s JSON-Schema definition
+		 * via the `patternProperty` "^x-".
+		 */
+		[k: string]: unknown;
+	};
+	placement?: {
+		constraints?: string[];
+		preferences?: {
+			spread?: string;
+			/**
+			 * This interface was referenced by `undefined`'s JSON-Schema definition
+			 * via the `patternProperty` "^x-".
+			 */
+			[k: string]: unknown;
+		}[];
+		max_replicas_per_node?: number;
+		/**
+		 * This interface was referenced by `undefined`'s JSON-Schema definition
+		 * via the `patternProperty` "^x-".
+		 */
+		[k: string]: unknown;
+	};
+	/**
+	 * This interface was referenced by `undefined`'s JSON-Schema definition
+	 * via the `patternProperty` "^x-".
+	 *
+	 * This interface was referenced by `undefined`'s JSON-Schema definition
+	 * via the `patternProperty` "^x-".
+	 */
+	[k: string]: unknown;
+} | null;
+export type ServiceConfigOrSecret = (
+	| string
+	| {
+			source?: string;
+			target?: string;
+			uid?: string;
+			gid?: string;
+			mode?: number;
+			/**
+			 * This interface was referenced by `undefined`'s JSON-Schema definition
+			 * via the `patternProperty` "^x-".
+			 */
+			[k: string]: unknown;
+	  }
+)[];
+export type Command = null | string | string[];
+export type EnvFile =
+	| string
+	| (
+			| string
+			| {
+					path: string;
+					required?: boolean;
+			  }
+	  )[];
+/**
+ * This interface was referenced by `PropertiesNetworks`'s JSON-Schema definition
+ * via the `patternProperty` "^[a-zA-Z0-9._-]+$".
+ */
+export type DefinitionsNetwork = {
+	name?: string;
+	driver?: string;
+	driver_opts?: {
+		/**
+		 * This interface was referenced by `undefined`'s JSON-Schema definition
+		 * via the `patternProperty` "^.+$".
+		 */
+		[k: string]: string | number;
+	};
+	ipam?: {
+		driver?: string;
+		config?: {
+			subnet?: string;
+			ip_range?: string;
+			gateway?: string;
+			aux_addresses?: {
+				/**
+				 * This interface was referenced by `undefined`'s JSON-Schema definition
+				 * via the `patternProperty` "^.+$".
+				 */
+				[k: string]: string;
+			};
+			/**
+			 * This interface was referenced by `undefined`'s JSON-Schema definition
+			 * via the `patternProperty` "^x-".
+			 */
+			[k: string]: unknown;
+		}[];
+		options?: {
+			/**
+			 * This interface was referenced by `undefined`'s JSON-Schema definition
+			 * via the `patternProperty` "^.+$".
+			 */
+			[k: string]: string;
+		};
+		/**
+		 * This interface was referenced by `undefined`'s JSON-Schema definition
+		 * via the `patternProperty` "^x-".
+		 */
+		[k: string]: unknown;
+	};
+	external?:
+		| boolean
+		| {
+				name?: string;
+				/**
+				 * This interface was referenced by `undefined`'s JSON-Schema definition
+				 * via the `patternProperty` "^x-".
+				 */
+				[k: string]: unknown;
+		  };
+	internal?: boolean;
+	enable_ipv6?: boolean;
+	attachable?: boolean;
+	labels?: ListOrDict;
+	/**
+	 * This interface was referenced by `undefined`'s JSON-Schema definition
+	 * via the `patternProperty` "^x-".
+	 *
+	 * This interface was referenced by `undefined`'s JSON-Schema definition
+	 * via the `patternProperty` "^x-".
+	 */
+	[k: string]: unknown;
+} & Network;
+export type Network = {
+	name?: string;
+	driver?: string;
+	driver_opts?: {
+		/**
+		 * This interface was referenced by `undefined`'s JSON-Schema definition
+		 * via the `patternProperty` "^.+$".
+		 */
+		[k: string]: string | number;
+	};
+	ipam?: {
+		driver?: string;
+		config?: {
+			subnet?: string;
+			ip_range?: string;
+			gateway?: string;
+			aux_addresses?: {
+				/**
+				 * This interface was referenced by `undefined`'s JSON-Schema definition
+				 * via the `patternProperty` "^.+$".
+				 */
+				[k: string]: string;
+			};
+			/**
+			 * This interface was referenced by `undefined`'s JSON-Schema definition
+			 * via the `patternProperty` "^x-".
+			 */
+			[k: string]: unknown;
+		}[];
+		options?: {
+			/**
+			 * This interface was referenced by `undefined`'s JSON-Schema definition
+			 * via the `patternProperty` "^.+$".
+			 */
+			[k: string]: string;
+		};
+		/**
+		 * This interface was referenced by `undefined`'s JSON-Schema definition
+		 * via the `patternProperty` "^x-".
+		 */
+		[k: string]: unknown;
+	};
+	external?:
+		| boolean
+		| {
+				name?: string;
+				/**
+				 * This interface was referenced by `undefined`'s JSON-Schema definition
+				 * via the `patternProperty` "^x-".
+				 */
+				[k: string]: unknown;
+		  };
+	internal?: boolean;
+	enable_ipv6?: boolean;
+	attachable?: boolean;
+	labels?: ListOrDict;
+	/**
+	 * This interface was referenced by `undefined`'s JSON-Schema definition
+	 * via the `patternProperty` "^x-".
+	 *
+	 * This interface was referenced by `undefined`'s JSON-Schema definition
+	 * via the `patternProperty` "^x-".
+	 */
+	[k: string]: unknown;
+} | null;
+/**
+ * This interface was referenced by `PropertiesVolumes`'s JSON-Schema definition
+ * via the `patternProperty` "^[a-zA-Z0-9._-]+$".
+ */
+export type DefinitionsVolume = {
+	name?: string;
+	driver?: string;
+	driver_opts?: {
+		/**
+		 * This interface was referenced by `undefined`'s JSON-Schema definition
+		 * via the `patternProperty` "^.+$".
+		 */
+		[k: string]: string | number;
+	};
+	external?:
+		| boolean
+		| {
+				name?: string;
+				/**
+				 * This interface was referenced by `undefined`'s JSON-Schema definition
+				 * via the `patternProperty` "^x-".
+				 */
+				[k: string]: unknown;
+		  };
+	labels?: ListOrDict;
+	/**
+	 * This interface was referenced by `undefined`'s JSON-Schema definition
+	 * via the `patternProperty` "^x-".
+	 *
+	 * This interface was referenced by `undefined`'s JSON-Schema definition
+	 * via the `patternProperty` "^x-".
+	 */
+	[k: string]: unknown;
+} & Volume;
+export type Volume = {
+	name?: string;
+	driver?: string;
+	driver_opts?: {
+		/**
+		 * This interface was referenced by `undefined`'s JSON-Schema definition
+		 * via the `patternProperty` "^.+$".
+		 */
+		[k: string]: string | number;
+	};
+	external?:
+		| boolean
+		| {
+				name?: string;
+				/**
+				 * This interface was referenced by `undefined`'s JSON-Schema definition
+				 * via the `patternProperty` "^x-".
+				 */
+				[k: string]: unknown;
+		  };
+	labels?: ListOrDict;
+	/**
+	 * This interface was referenced by `undefined`'s JSON-Schema definition
+	 * via the `patternProperty` "^x-".
+	 *
+	 * This interface was referenced by `undefined`'s JSON-Schema definition
+	 * via the `patternProperty` "^x-".
+	 */
+	[k: string]: unknown;
+} | null;
+
+/**
+ * The Compose file is a YAML file defining a multi-containers based application.
+ */
+export interface ComposeSpecification {
+	/**
+	 * declared for backward compatibility, ignored.
+	 */
+	version?: string;
+	/**
+	 * define the Compose project name, until user defines one explicitly.
+	 */
+	name?: string;
+	/**
+	 * compose sub-projects to be included.
+	 */
+	include?: DefinitionsInclude[];
+	services?: PropertiesServices;
+	networks?: PropertiesNetworks;
+	volumes?: PropertiesVolumes;
+	secrets?: PropertiesSecrets;
+	configs?: PropertiesConfigs;
+	/**
+	 * This interface was referenced by `ComposeSpecification`'s JSON-Schema definition
+	 * via the `patternProperty` "^x-".
+	 */
+	[k: string]: unknown;
+}
+export interface PropertiesServices {
+	[k: string]: DefinitionsService;
+}
+/**
+ * This interface was referenced by `PropertiesServices`'s JSON-Schema definition
+ * via the `patternProperty` "^[a-zA-Z0-9._-]+$".
+ */
+export interface DefinitionsService {
+	develop?: DefinitionsDevelopment;
+	deploy?: DefinitionsDeployment;
+	annotations?: ListOrDict;
+	attach?: boolean;
+	build?:
+		| string
+		| {
+				context?: string;
+				dockerfile?: string;
+				dockerfile_inline?: string;
+				entitlements?: string[];
+				args?: ListOrDict;
+				ssh?: ListOrDict;
+				labels?: ListOrDict;
+				cache_from?: string[];
+				cache_to?: string[];
+				no_cache?: boolean;
+				additional_contexts?: ListOrDict;
+				network?: string;
+				pull?: boolean;
+				target?: string;
+				shm_size?: number | string;
+				extra_hosts?: ListOrDict;
+				isolation?: string;
+				privileged?: boolean;
+				secrets?: ServiceConfigOrSecret;
+				tags?: string[];
+				ulimits?: Ulimits;
+				platforms?: string[];
+				/**
+				 * This interface was referenced by `undefined`'s JSON-Schema definition
+				 * via the `patternProperty` "^x-".
+				 */
+				[k: string]: unknown;
+		  };
+	blkio_config?: {
+		device_read_bps?: BlkioLimit[];
+		device_read_iops?: BlkioLimit[];
+		device_write_bps?: BlkioLimit[];
+		device_write_iops?: BlkioLimit[];
+		weight?: number;
+		weight_device?: BlkioWeight[];
+	};
+	cap_add?: string[];
+	cap_drop?: string[];
+	cgroup?: "host" | "private";
+	cgroup_parent?: string;
+	command?: Command;
+	configs?: ServiceConfigOrSecret;
+	container_name?: string;
+	cpu_count?: number;
+	cpu_percent?: number;
+	cpu_shares?: number | string;
+	cpu_quota?: number | string;
+	cpu_period?: number | string;
+	cpu_rt_period?: number | string;
+	cpu_rt_runtime?: number | string;
+	cpus?: number | string;
+	cpuset?: string;
+	credential_spec?: {
+		config?: string;
+		file?: string;
+		registry?: string;
+		/**
+		 * This interface was referenced by `undefined`'s JSON-Schema definition
+		 * via the `patternProperty` "^x-".
+		 */
+		[k: string]: unknown;
+	};
+	depends_on?:
+		| ListOfStrings
+		| {
+				/**
+				 * This interface was referenced by `undefined`'s JSON-Schema definition
+				 * via the `patternProperty` "^[a-zA-Z0-9._-]+$".
+				 */
+				[k: string]: {
+					restart?: boolean;
+					required?: boolean;
+					condition:
+						| "service_started"
+						| "service_healthy"
+						| "service_completed_successfully";
+				};
+		  };
+	device_cgroup_rules?: ListOfStrings;
+	devices?: string[];
+	dns?: StringOrList;
+	dns_opt?: string[];
+	dns_search?: StringOrList;
+	domainname?: string;
+	entrypoint?: Command;
+	env_file?: EnvFile;
+	environment?: ListOrDict;
+	expose?: (string | number)[];
+	extends?:
+		| string
+		| {
+				service: string;
+				file?: string;
+		  };
+	external_links?: string[];
+	extra_hosts?: ListOrDict;
+	group_add?: (string | number)[];
+	healthcheck?: DefinitionsHealthcheck;
+	hostname?: string;
+	image?: string;
+	init?: boolean;
+	ipc?: string;
+	isolation?: string;
+	labels?: ListOrDict;
+	links?: string[];
+	logging?: {
+		driver?: string;
+		options?: {
+			/**
+			 * This interface was referenced by `undefined`'s JSON-Schema definition
+			 * via the `patternProperty` "^.+$".
+			 */
+			[k: string]: string | number | null;
+		};
+		/**
+		 * This interface was referenced by `undefined`'s JSON-Schema definition
+		 * via the `patternProperty` "^x-".
+		 */
+		[k: string]: unknown;
+	};
+	mac_address?: string;
+	mem_limit?: number | string;
+	mem_reservation?: string | number;
+	mem_swappiness?: number;
+	memswap_limit?: number | string;
+	network_mode?: string;
+	networks?:
+		| ListOfStrings
+		| {
+				/**
+				 * This interface was referenced by `undefined`'s JSON-Schema definition
+				 * via the `patternProperty` "^[a-zA-Z0-9._-]+$".
+				 */
+				[k: string]: {
+					aliases?: ListOfStrings;
+					ipv4_address?: string;
+					ipv6_address?: string;
+					link_local_ips?: ListOfStrings;
+					mac_address?: string;
+					driver_opts?: {
+						/**
+						 * This interface was referenced by `undefined`'s JSON-Schema definition
+						 * via the `patternProperty` "^.+$".
+						 */
+						[k: string]: string | number;
+					};
+					priority?: number;
+					/**
+					 * This interface was referenced by `undefined`'s JSON-Schema definition
+					 * via the `patternProperty` "^x-".
+					 */
+					[k: string]: unknown;
+				} | null;
+		  };
+	oom_kill_disable?: boolean;
+	oom_score_adj?: number;
+	pid?: string | null;
+	pids_limit?: number | string;
+	platform?: string;
+	ports?: (
+		| number
+		| string
+		| {
+				name?: string;
+				mode?: string;
+				host_ip?: string;
+				target?: number;
+				published?: string | number;
+				protocol?: string;
+				app_protocol?: string;
+				/**
+				 * This interface was referenced by `undefined`'s JSON-Schema definition
+				 * via the `patternProperty` "^x-".
+				 */
+				[k: string]: unknown;
+		  }
+	)[];
+	privileged?: boolean;
+	profiles?: ListOfStrings;
+	pull_policy?: "always" | "never" | "if_not_present" | "build" | "missing";
+	read_only?: boolean;
+	restart?: string;
+	runtime?: string;
+	scale?: number;
+	security_opt?: string[];
+	shm_size?: number | string;
+	secrets?: ServiceConfigOrSecret;
+	sysctls?: ListOrDict;
+	stdin_open?: boolean;
+	stop_grace_period?: string;
+	stop_signal?: string;
+	storage_opt?: {
+		[k: string]: unknown;
+	};
+	tmpfs?: StringOrList;
+	tty?: boolean;
+	ulimits?: Ulimits;
+	user?: string;
+	uts?: string;
+	userns_mode?: string;
+	volumes?: (
+		| string
+		| {
+				type: string;
+				source?: string;
+				target?: string;
+				read_only?: boolean;
+				consistency?: string;
+				bind?: {
+					propagation?: string;
+					create_host_path?: boolean;
+					selinux?: "z" | "Z";
+					/**
+					 * This interface was referenced by `undefined`'s JSON-Schema definition
+					 * via the `patternProperty` "^x-".
+					 */
+					[k: string]: unknown;
+				};
+				volume?: {
+					nocopy?: boolean;
+					subpath?: string;
+					/**
+					 * This interface was referenced by `undefined`'s JSON-Schema definition
+					 * via the `patternProperty` "^x-".
+					 */
+					[k: string]: unknown;
+				};
+				tmpfs?: {
+					size?: number | string;
+					mode?: number;
+					/**
+					 * This interface was referenced by `undefined`'s JSON-Schema definition
+					 * via the `patternProperty` "^x-".
+					 */
+					[k: string]: unknown;
+				};
+				/**
+				 * This interface was referenced by `undefined`'s JSON-Schema definition
+				 * via the `patternProperty` "^x-".
+				 */
+				[k: string]: unknown;
+		  }
+	)[];
+	volumes_from?: string[];
+	working_dir?: string;
+	/**
+	 * This interface was referenced by `DefinitionsService`'s JSON-Schema definition
+	 * via the `patternProperty` "^x-".
+	 */
+	[k: string]: unknown;
+}
+export interface Ulimits {
+	/**
+	 * This interface was referenced by `Ulimits`'s JSON-Schema definition
+	 * via the `patternProperty` "^[a-z]+$".
+	 */
+	[k: string]:
+		| number
+		| {
+				hard: number;
+				soft: number;
+				/**
+				 * This interface was referenced by `undefined`'s JSON-Schema definition
+				 * via the `patternProperty` "^x-".
+				 */
+				[k: string]: unknown;
+		  };
+}
+export interface BlkioLimit {
+	path?: string;
+	rate?: number | string;
+}
+export interface BlkioWeight {
+	path?: string;
+	weight?: number;
+}
+export interface DefinitionsHealthcheck {
+	disable?: boolean;
+	interval?: string;
+	retries?: number;
+	test?: string | string[];
+	timeout?: string;
+	start_period?: string;
+	start_interval?: string;
+	/**
+	 * This interface was referenced by `DefinitionsHealthcheck`'s JSON-Schema definition
+	 * via the `patternProperty` "^x-".
+	 */
+	[k: string]: unknown;
+}
+export interface PropertiesNetworks {
+	[k: string]: DefinitionsNetwork;
+}
+export interface PropertiesVolumes {
+	[k: string]: DefinitionsVolume;
+}
+export interface PropertiesSecrets {
+	[k: string]: DefinitionsSecret;
+}
+/**
+ * This interface was referenced by `PropertiesSecrets`'s JSON-Schema definition
+ * via the `patternProperty` "^[a-zA-Z0-9._-]+$".
+ */
+export interface DefinitionsSecret {
+	name?: string;
+	environment?: string;
+	file?: string;
+	external?:
+		| boolean
+		| {
+				name?: string;
+				[k: string]: unknown;
+		  };
+	labels?: ListOrDict;
+	driver?: string;
+	driver_opts?: {
+		/**
+		 * This interface was referenced by `undefined`'s JSON-Schema definition
+		 * via the `patternProperty` "^.+$".
+		 */
+		[k: string]: string | number;
+	};
+	template_driver?: string;
+	/**
+	 * This interface was referenced by `DefinitionsSecret`'s JSON-Schema definition
+	 * via the `patternProperty` "^x-".
+	 */
+	[k: string]: unknown;
+}
+export interface PropertiesConfigs {
+	[k: string]: DefinitionsConfig;
+}
+/**
+ * This interface was referenced by `PropertiesConfigs`'s JSON-Schema definition
+ * via the `patternProperty` "^[a-zA-Z0-9._-]+$".
+ */
+export interface DefinitionsConfig {
+	name?: string;
+	content?: string;
+	environment?: string;
+	file?: string;
+	external?:
+		| boolean
+		| {
+				name?: string;
+				[k: string]: unknown;
+		  };
+	labels?: ListOrDict;
+	template_driver?: string;
+	/**
+	 * This interface was referenced by `DefinitionsConfig`'s JSON-Schema definition
+	 * via the `patternProperty` "^x-".
+	 */
+	[k: string]: unknown;
+}

server/utils/docker/utils.ts

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import type { Readable } from "node:stream";
-import { APPLICATIONS_PATH, docker } from "@/server/constants";
+import { APPLICATIONS_PATH, COMPOSE_PATH, docker } from "@/server/constants";
 import type { ContainerInfo, ResourceRequirements } from "dockerode";
 import type { ApplicationNested } from "../builders";
 import { execAsync } from "../process/execAsync";
@@ -324,6 +324,33 @@ export const generateFileMounts = (
 		});
 };
 
+export const generateFileMountsCompose = (
+	appName: string,
+	mounts: ApplicationNested["mounts"],
+) => {
+	if (!mounts || mounts.length === 0) {
+		return [];
+	}
+
+	return mounts
+		.filter((mount) => mount.type === "file")
+		.map((mount) => {
+			const fileName = path.basename(mount.mountPath);
+			const directory = path.join(
+				COMPOSE_PATH,
+				appName,
+				path.dirname(mount.mountPath),
+			);
+			fs.mkdirSync(directory, { recursive: true });
+
+			const filePath = path.join(directory, fileName);
+
+			fs.writeFileSync(filePath, mount.content || "");
+
+			return {};
+		});
+};
+
 export const getServiceContainer = async (appName: string) => {
 	try {
 		const filter = {

server/utils/filesystem/directory.ts

@@ -1,7 +1,11 @@
 import fs, { promises as fsPromises } from "node:fs";
 import path from "node:path";
 import type { Application } from "@/server/api/services/application";
-import { APPLICATIONS_PATH, MONITORING_PATH } from "@/server/constants";
+import {
+	APPLICATIONS_PATH,
+	COMPOSE_PATH,
+	MONITORING_PATH,
+} from "@/server/constants";
 import { execAsync } from "../process/execAsync";
 
 export const recreateDirectory = async (pathFolder: string): Promise<void> => {
@@ -32,6 +36,16 @@ export const removeDirectoryCode = async (appName: string) => {
 	}
 };
 
+export const removeComposeDirectory = async (appName: string) => {
+	const directoryPath = path.join(COMPOSE_PATH, appName);
+	try {
+		await execAsync(`rm -rf ${directoryPath}`);
+	} catch (error) {
+		console.error(`Error to remove ${directoryPath}: ${error}`);
+		throw error;
+	}
+};
+
 export const removeMonitoringDirectory = async (appName: string) => {
 	const directoryPath = path.join(MONITORING_PATH, appName);
 	try {

server/utils/process/spawnAsync.ts

@@ -1,58 +1,58 @@
 import {
-  type ChildProcess,
-  type SpawnOptions,
-  spawn,
+	type ChildProcess,
+	type SpawnOptions,
+	spawn,
 } from "node:child_process";
 import BufferList from "bl";
 
 export const spawnAsync = (
-  command: string,
-  args?: string[] | undefined,
-  onData?: (data: string) => void, // Callback opcional para manejar datos en tiempo real
-  options?: SpawnOptions,
+	command: string,
+	args?: string[] | undefined,
+	onData?: (data: string) => void, // Callback opcional para manejar datos en tiempo real
+	options?: SpawnOptions,
 ): Promise<BufferList> & { child: ChildProcess } => {
-  const child = spawn(command, args ?? [], options ?? {});
-  const stdout = child.stdout ? new BufferList() : new BufferList();
-  const stderr = child.stderr ? new BufferList() : new BufferList();
+	const child = spawn(command, args ?? [], options ?? {});
+	const stdout = child.stdout ? new BufferList() : new BufferList();
+	const stderr = child.stderr ? new BufferList() : new BufferList();
 
-  if (child.stdout) {
-    child.stdout.on("data", (data) => {
-      stdout.append(data);
-      if (onData) {
-        onData(data.toString());
-      }
-    });
-  }
-  if (child.stderr) {
-    child.stderr.on("data", (data) => {
-      stderr.append(data);
-      if (onData) {
-        onData(data.toString());
-      }
-    });
-  }
+	if (child.stdout) {
+		child.stdout.on("data", (data) => {
+			stdout.append(data);
+			if (onData) {
+				onData(data.toString());
+			}
+		});
+	}
+	if (child.stderr) {
+		child.stderr.on("data", (data) => {
+			stderr.append(data);
+			if (onData) {
+				onData(data.toString());
+			}
+		});
+	}
 
-  const promise = new Promise<BufferList>((resolve, reject) => {
-    child.on("error", reject);
+	const promise = new Promise<BufferList>((resolve, reject) => {
+		child.on("error", reject);
 
-    child.on("close", (code) => {
-      if (code === 0) {
-        resolve(stdout);
-      } else {
-        const err = new Error(`child exited with code ${code}`) as Error & {
-          code: number;
-          stderr: BufferList;
-          stdout: BufferList;
-        };
-        err.code = code || -1;
-        err.stderr = stderr;
-        err.stdout = stdout;
-        reject(err);
-      }
-    });
-  }) as Promise<BufferList> & { child: ChildProcess };
+		child.on("close", (code) => {
+			if (code === 0) {
+				resolve(stdout);
+			} else {
+				const err = new Error(`child exited with code ${code}`) as Error & {
+					code: number;
+					stderr: BufferList;
+					stdout: BufferList;
+				};
+				err.code = code || -1;
+				err.stderr = stderr;
+				err.stdout = stdout;
+				reject(err);
+			}
+		});
+	}) as Promise<BufferList> & { child: ChildProcess };
 
-  promise.child = child;
+	promise.child = child;
 
-  return promise;
+	return promise;
 };

server/utils/providers/git.ts

@@ -1,18 +1,22 @@
 import { createWriteStream } from "node:fs";
-import path from "node:path";
-import type { Application } from "@/server/api/services/application";
-import { APPLICATIONS_PATH, SSH_PATH } from "@/server/constants";
+import path, { join } from "node:path";
+import { APPLICATIONS_PATH, COMPOSE_PATH, SSH_PATH } from "@/server/constants";
 import { TRPCError } from "@trpc/server";
 import { recreateDirectory } from "../filesystem/directory";
 import { execAsync } from "../process/execAsync";
 import { spawnAsync } from "../process/spawnAsync";
 
 export const cloneGitRepository = async (
-	application: Application,
+	entity: {
+		appName: string;
+		customGitUrl?: string | null;
+		customGitBranch?: string | null;
+		customGitSSHKey?: string | null;
+	},
 	logPath: string,
+	isCompose = false,
 ) => {
-	const { appName, customGitUrl, customGitBranch, customGitSSHKey } =
-		application;
+	const { appName, customGitUrl, customGitBranch, customGitSSHKey } = entity;
 
 	if (!customGitUrl || !customGitBranch) {
 		throw new TRPCError({
@@ -23,7 +27,8 @@ export const cloneGitRepository = async (
 
 	const writeStream = createWriteStream(logPath, { flags: "a" });
 	const keyPath = path.join(SSH_PATH, `${appName}_rsa`);
-	const outputPath = path.join(APPLICATIONS_PATH, appName);
+	const basePath = isCompose ? COMPOSE_PATH : APPLICATIONS_PATH;
+	const outputPath = join(basePath, appName);
 	const knownHostsPath = path.join(SSH_PATH, "known_hosts");
 
 	try {

server/utils/providers/github.ts

@@ -1,7 +1,6 @@
 import { createWriteStream } from "node:fs";
-import path from "node:path";
-import type { Application } from "@/server/api/services/application";
-import { APPLICATIONS_PATH } from "@/server/constants";
+import { join } from "node:path";
+import { APPLICATIONS_PATH, COMPOSE_PATH } from "@/server/constants";
 import { createAppAuth } from "@octokit/auth-app";
 import { TRPCError } from "@trpc/server";
 import { Octokit } from "octokit";
@@ -49,25 +48,36 @@ export const haveGithubRequirements = (admin: Admin) => {
 	);
 };
 
-const getErrorCloneRequirements = (application: Application) => {
+const getErrorCloneRequirements = (entity: {
+	repository?: string | null;
+	owner?: string | null;
+	branch?: string | null;
+}) => {
 	const reasons: string[] = [];
-	const { repository, owner, branch } = application;
+	const { repository, owner, branch } = entity;
 
 	if (!repository) reasons.push("1. Repository not assigned.");
-	if (!owner) reasons.push("2. Owner not specified .");
+	if (!owner) reasons.push("2. Owner not specified.");
 	if (!branch) reasons.push("3. Branch not defined.");
 
 	return reasons;
 };
+
 export const cloneGithubRepository = async (
 	admin: Admin,
-	application: Application,
+	entity: {
+		appName: string;
+		repository?: string | null;
+		owner?: string | null;
+		branch?: string | null;
+	},
 	logPath: string,
+	isCompose = false,
 ) => {
 	const writeStream = createWriteStream(logPath, { flags: "a" });
-	const { appName, repository, owner, branch } = application;
+	const { appName, repository, owner, branch } = entity;
 
-	const requirements = getErrorCloneRequirements(application);
+	const requirements = getErrorCloneRequirements(entity);
 
 	// Check if requirements are met
 	if (requirements.length > 0) {
@@ -82,7 +92,8 @@ export const cloneGithubRepository = async (
 			message: "Error: GitHub repository information is incomplete.",
 		});
 	}
-	const outputPath = path.join(APPLICATIONS_PATH, appName);
+	const basePath = isCompose ? COMPOSE_PATH : APPLICATIONS_PATH;
+	const outputPath = join(basePath, appName);
 	const octokit = authGithub(admin);
 	const token = await getGithubToken(octokit);
 	const repoclone = `github.com/${owner}/${repository}.git`;

server/utils/providers/raw.ts

@@ -0,0 +1,28 @@
+import type { Compose } from "@/server/api/services/compose";
+import { COMPOSE_PATH } from "@/server/constants";
+import { createWriteStream } from "node:fs";
+import { join } from "node:path";
+import { recreateDirectory } from "../filesystem/directory";
+import { writeFile } from "node:fs/promises";
+
+export const createComposeFile = async (compose: Compose, logPath: string) => {
+	const { appName, composeFile } = compose;
+	const writeStream = createWriteStream(logPath, { flags: "a" });
+	const outputPath = join(COMPOSE_PATH, appName);
+
+	try {
+		await recreateDirectory(outputPath);
+		writeStream.write(
+			`\nCreating File 'docker-compose.yml' to ${outputPath}: ✅\n`,
+		);
+
+		await writeFile(join(outputPath, "docker-compose.yml"), composeFile);
+
+		writeStream.write(`\nFile 'docker-compose.yml' created: ✅\n`);
+	} catch (error) {
+		writeStream.write(`\nERROR Creating Compose File: ${error}: ❌\n`);
+		throw error;
+	} finally {
+		writeStream.end();
+	}
+};