refactor: rename builders to server

packages/server/src/utils/docker/compose.ts

@@ -0,0 +1,56 @@
+import crypto from "node:crypto";
+import { findComposeById } from "@/server/services/compose";
+import { dump, load } from "js-yaml";
+import { addSuffixToAllConfigs } from "./compose/configs";
+import { addSuffixToAllNetworks } from "./compose/network";
+import { addSuffixToAllSecrets } from "./compose/secrets";
+import { addSuffixToAllServiceNames } from "./compose/service";
+import { addSuffixToAllVolumes } from "./compose/volume";
+import type { ComposeSpecification } from "./types";
+
+export const generateRandomHash = (): string => {
+	return crypto.randomBytes(4).toString("hex");
+};
+
+export const randomizeComposeFile = async (
+	composeId: string,
+	suffix?: string,
+) => {
+	const compose = await findComposeById(composeId);
+	const composeFile = compose.composeFile;
+	const composeData = load(composeFile) as ComposeSpecification;
+
+	const randomSuffix = suffix || generateRandomHash();
+
+	const newComposeFile = addSuffixToAllProperties(composeData, randomSuffix);
+
+	return dump(newComposeFile);
+};
+
+export const randomizeSpecificationFile = (
+	composeSpec: ComposeSpecification,
+	suffix?: string,
+) => {
+	if (!suffix) {
+		return composeSpec;
+	}
+	const newComposeFile = addSuffixToAllProperties(composeSpec, suffix);
+	return newComposeFile;
+};
+
+export const addSuffixToAllProperties = (
+	composeData: ComposeSpecification,
+	suffix: string,
+): ComposeSpecification => {
+	let updatedComposeData = { ...composeData };
+
+	updatedComposeData = addSuffixToAllServiceNames(updatedComposeData, suffix);
+
+	updatedComposeData = addSuffixToAllVolumes(updatedComposeData, suffix);
+
+	updatedComposeData = addSuffixToAllNetworks(updatedComposeData, suffix);
+	updatedComposeData = addSuffixToAllConfigs(updatedComposeData, suffix);
+
+	updatedComposeData = addSuffixToAllSecrets(updatedComposeData, suffix);
+	return updatedComposeData;
+};

packages/server/src/utils/docker/compose/configs.ts

@@ -0,0 +1,73 @@
+import _ from "lodash";
+import type {
+	ComposeSpecification,
+	DefinitionsConfig,
+	DefinitionsService,
+} from "../types";
+
+export const addSuffixToConfigsRoot = (
+	configs: { [key: string]: DefinitionsConfig },
+	suffix: string,
+): { [key: string]: DefinitionsConfig } => {
+	const newConfigs: { [key: string]: DefinitionsConfig } = {};
+
+	_.forEach(configs, (config, configName) => {
+		const newConfigName = `${configName}-${suffix}`;
+		newConfigs[newConfigName] = _.cloneDeep(config);
+	});
+
+	return newConfigs;
+};
+
+export const addSuffixToConfigsInServices = (
+	services: { [key: string]: DefinitionsService },
+	suffix: 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}-${suffix}`;
+				}
+				if (_.isObject(config) && config.source) {
+					return {
+						...config,
+						source: `${config.source}-${suffix}`,
+					};
+				}
+				return config;
+			});
+		}
+
+		newServices[serviceName] = newServiceConfig;
+	});
+
+	return newServices;
+};
+
+export const addSuffixToAllConfigs = (
+	composeData: ComposeSpecification,
+	suffix: string,
+): ComposeSpecification => {
+	const updatedComposeData = { ...composeData };
+	if (composeData?.configs) {
+		updatedComposeData.configs = addSuffixToConfigsRoot(
+			composeData.configs,
+			suffix,
+		);
+	}
+
+	if (composeData?.services) {
+		updatedComposeData.services = addSuffixToConfigsInServices(
+			composeData.services,
+			suffix,
+		);
+	}
+
+	return updatedComposeData;
+};

packages/server/src/utils/docker/compose/network.ts

@@ -0,0 +1,83 @@
+import _ from "lodash";
+import type {
+	ComposeSpecification,
+	DefinitionsNetwork,
+	DefinitionsService,
+} from "../types";
+
+export const addSuffixToNetworksRoot = (
+	networks: { [key: string]: DefinitionsNetwork },
+	suffix: string,
+): { [key: string]: DefinitionsNetwork } => {
+	return _.mapKeys(networks, (_value, key) => {
+		if (key === "dokploy-network") {
+			return "dokploy-network";
+		}
+		return `${key}-${suffix}`;
+	});
+};
+
+export const addSuffixToServiceNetworks = (
+	services: { [key: string]: DefinitionsService },
+	suffix: 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) => {
+					if (network === "dokploy-network") {
+						return "dokploy-network";
+					}
+					return `${network}-${suffix}`;
+				});
+			} else {
+				// 2 Case
+				service.networks = _.mapKeys(service.networks, (_value, key) => {
+					if (key === "dokploy-network") {
+						return "dokploy-network";
+					}
+					return `${key}-${suffix}`;
+				});
+
+				// 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}-${suffix}`;
+						});
+					}
+
+					return value;
+				});
+			}
+		}
+		return service;
+	});
+};
+
+export const addSuffixToAllNetworks = (
+	composeData: ComposeSpecification,
+	suffix: string,
+): ComposeSpecification => {
+	const updatedComposeData = { ...composeData };
+
+	if (updatedComposeData.networks) {
+		updatedComposeData.networks = addSuffixToNetworksRoot(
+			updatedComposeData.networks,
+			suffix,
+		);
+	}
+
+	if (updatedComposeData.services) {
+		updatedComposeData.services = addSuffixToServiceNetworks(
+			updatedComposeData.services,
+			suffix,
+		);
+	}
+
+	return updatedComposeData;
+};

packages/server/src/utils/docker/compose/secrets.ts

@@ -0,0 +1,68 @@
+import _ from "lodash";
+import type { ComposeSpecification, DefinitionsService } from "../types";
+
+export const addSuffixToSecretsRoot = (
+	secrets: ComposeSpecification["secrets"],
+	suffix: string,
+): ComposeSpecification["secrets"] => {
+	const newSecrets: ComposeSpecification["secrets"] = {};
+	_.forEach(secrets, (secretConfig, secretName) => {
+		const newSecretName = `${secretName}-${suffix}`;
+		newSecrets[newSecretName] = _.cloneDeep(secretConfig);
+	});
+	return newSecrets;
+};
+
+export const addSuffixToSecretsInServices = (
+	services: { [key: string]: DefinitionsService },
+	suffix: 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}-${suffix}`;
+				}
+				if (_.isObject(secret) && secret.source) {
+					return {
+						...secret,
+						source: `${secret.source}-${suffix}`,
+					};
+				}
+				return secret;
+			});
+		}
+
+		newServices[serviceName] = newServiceConfig;
+	});
+
+	return newServices;
+};
+
+export const addSuffixToAllSecrets = (
+	composeData: ComposeSpecification,
+	suffix: string,
+): ComposeSpecification => {
+	const updatedComposeData = { ...composeData };
+
+	if (composeData?.secrets) {
+		updatedComposeData.secrets = addSuffixToSecretsRoot(
+			composeData.secrets,
+			suffix,
+		);
+	}
+
+	if (composeData?.services) {
+		updatedComposeData.services = addSuffixToSecretsInServices(
+			composeData.services,
+			suffix,
+		);
+	}
+
+	return updatedComposeData;
+};

packages/server/src/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 addSuffixToServiceNames = (
+	services: { [key: string]: DefinitionsService },
+	suffix: string,
+): { [key: string]: DefinitionsService } => {
+	const newServices: { [key: string]: DefinitionsService } = {};
+
+	for (const [serviceName, serviceConfig] of Object.entries(services)) {
+		const newServiceName = `${serviceName}-${suffix}`;
+		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}-${suffix}`,
+				);
+			} else {
+				const newDependsOn: DependsOnObject = {};
+				for (const [depName, depConfig] of Object.entries(
+					newServiceConfig.depends_on,
+				)) {
+					newDependsOn[`${depName}-${suffix}`] = depConfig;
+				}
+				newServiceConfig.depends_on = newDependsOn;
+			}
+		}
+
+		// Reemplazar nombre en container_name
+		if (newServiceConfig.container_name) {
+			newServiceConfig.container_name = `${newServiceConfig.container_name}-${suffix}`;
+		}
+
+		// Reemplazar nombres de servicios en links
+		if (newServiceConfig.links) {
+			newServiceConfig.links = newServiceConfig.links.map(
+				(link) => `${link}-${suffix}`,
+			);
+		}
+
+		// Reemplazar nombres de servicios en extends
+		if (newServiceConfig.extends) {
+			if (typeof newServiceConfig.extends === "string") {
+				newServiceConfig.extends = `${newServiceConfig.extends}-${suffix}`;
+			} else {
+				newServiceConfig.extends.service = `${newServiceConfig.extends.service}-${suffix}`;
+			}
+		}
+
+		// Reemplazar nombres de servicios en volumes_from
+		if (newServiceConfig.volumes_from) {
+			newServiceConfig.volumes_from = newServiceConfig.volumes_from.map(
+				(vol) => `${vol}-${suffix}`,
+			);
+		}
+
+		newServices[newServiceName] = newServiceConfig;
+	}
+
+	return newServices;
+};
+
+export const addSuffixToAllServiceNames = (
+	composeData: ComposeSpecification,
+	suffix: string,
+): ComposeSpecification => {
+	const updatedComposeData = { ...composeData };
+
+	if (updatedComposeData.services) {
+		updatedComposeData.services = addSuffixToServiceNames(
+			updatedComposeData.services,
+			suffix,
+		);
+	}
+
+	return updatedComposeData;
+};

packages/server/src/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 addSuffixToVolumesRoot = (
+	volumes: { [key: string]: DefinitionsVolume },
+	suffix: string,
+): { [key: string]: DefinitionsVolume } => {
+	return _.mapKeys(volumes, (_value, key) => `${key}-${suffix}`);
+};
+
+export const addSuffixToVolumesInServices = (
+	services: { [key: string]: DefinitionsService },
+	suffix: 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}-${suffix}:${path}`;
+				}
+				if (_.isObject(volume) && volume.type === "volume" && volume.source) {
+					return {
+						...volume,
+						source: `${volume.source}-${suffix}`,
+					};
+				}
+				return volume;
+			});
+		}
+
+		newServices[serviceName] = newServiceConfig;
+	});
+
+	return newServices;
+};
+
+export const addSuffixToAllVolumes = (
+	composeData: ComposeSpecification,
+	suffix: string,
+): ComposeSpecification => {
+	const updatedComposeData = { ...composeData };
+
+	if (updatedComposeData.volumes) {
+		updatedComposeData.volumes = addSuffixToVolumesRoot(
+			updatedComposeData.volumes,
+			suffix,
+		);
+	}
+
+	if (updatedComposeData.services) {
+		updatedComposeData.services = addSuffixToVolumesInServices(
+			updatedComposeData.services,
+			suffix,
+		);
+	}
+
+	return updatedComposeData;
+};

packages/server/src/utils/docker/domain.ts

@@ -0,0 +1,327 @@
+import fs, { existsSync, readFileSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { paths } from "@/server/constants";
+import type { Compose } from "@/server/services/compose";
+import type { Domain } from "@/server/services/domain";
+import { dump, load } from "js-yaml";
+import { execAsyncRemote } from "../process/execAsync";
+import {
+	cloneRawBitbucketRepository,
+	cloneRawBitbucketRepositoryRemote,
+} from "../providers/bitbucket";
+import {
+	cloneGitRawRepository,
+	cloneRawGitRepositoryRemote,
+} from "../providers/git";
+import {
+	cloneRawGithubRepository,
+	cloneRawGithubRepositoryRemote,
+} from "../providers/github";
+import {
+	cloneRawGitlabRepository,
+	cloneRawGitlabRepositoryRemote,
+} from "../providers/gitlab";
+import {
+	createComposeFileRaw,
+	createComposeFileRawRemote,
+} from "../providers/raw";
+import { randomizeSpecificationFile } from "./compose";
+import type {
+	ComposeSpecification,
+	DefinitionsService,
+	PropertiesNetworks,
+} from "./types";
+import { encodeBase64 } from "./utils";
+
+export const cloneCompose = async (compose: Compose) => {
+	if (compose.sourceType === "github") {
+		await cloneRawGithubRepository(compose);
+	} else if (compose.sourceType === "gitlab") {
+		await cloneRawGitlabRepository(compose);
+	} else if (compose.sourceType === "bitbucket") {
+		await cloneRawBitbucketRepository(compose);
+	} else if (compose.sourceType === "git") {
+		await cloneGitRawRepository(compose);
+	} else if (compose.sourceType === "raw") {
+		await createComposeFileRaw(compose);
+	}
+};
+
+export const cloneComposeRemote = async (compose: Compose) => {
+	if (compose.sourceType === "github") {
+		await cloneRawGithubRepositoryRemote(compose);
+	} else if (compose.sourceType === "gitlab") {
+		await cloneRawGitlabRepositoryRemote(compose);
+	} else if (compose.sourceType === "bitbucket") {
+		await cloneRawBitbucketRepositoryRemote(compose);
+	} else if (compose.sourceType === "git") {
+		await cloneRawGitRepositoryRemote(compose);
+	} else if (compose.sourceType === "raw") {
+		await createComposeFileRawRemote(compose);
+	}
+};
+
+export const getComposePath = (compose: Compose) => {
+	const { COMPOSE_PATH } = paths(!!compose.serverId);
+	const { appName, sourceType, composePath } = compose;
+	let path = "";
+
+	if (sourceType === "raw") {
+		path = "docker-compose.yml";
+	} else {
+		path = composePath;
+	}
+
+	return join(COMPOSE_PATH, appName, "code", path);
+};
+
+export const loadDockerCompose = async (
+	compose: Compose,
+): Promise<ComposeSpecification | null> => {
+	const path = getComposePath(compose);
+
+	if (existsSync(path)) {
+		const yamlStr = readFileSync(path, "utf8");
+		const parsedConfig = load(yamlStr) as ComposeSpecification;
+		return parsedConfig;
+	}
+	return null;
+};
+
+export const loadDockerComposeRemote = async (
+	compose: Compose,
+): Promise<ComposeSpecification | null> => {
+	const path = getComposePath(compose);
+	try {
+		if (!compose.serverId) {
+			return null;
+		}
+		const { stdout, stderr } = await execAsyncRemote(
+			compose.serverId,
+			`cat ${path}`,
+		);
+
+		if (stderr) {
+			return null;
+		}
+		if (!stdout) return null;
+		const parsedConfig = load(stdout) as ComposeSpecification;
+		return parsedConfig;
+	} catch (err) {
+		return null;
+	}
+};
+
+export const readComposeFile = async (compose: Compose) => {
+	const path = getComposePath(compose);
+	if (existsSync(path)) {
+		const yamlStr = readFileSync(path, "utf8");
+		return yamlStr;
+	}
+	return null;
+};
+
+export const writeDomainsToCompose = async (
+	compose: Compose,
+	domains: Domain[],
+) => {
+	if (!domains.length) {
+		return;
+	}
+	const composeConverted = await addDomainToCompose(compose, domains);
+
+	const path = getComposePath(compose);
+	const composeString = dump(composeConverted, { lineWidth: 1000 });
+	try {
+		await writeFile(path, composeString, "utf8");
+	} catch (error) {
+		throw error;
+	}
+};
+
+export const writeDomainsToComposeRemote = async (
+	compose: Compose,
+	domains: Domain[],
+	logPath: string,
+) => {
+	if (!domains.length) {
+		return "";
+	}
+
+	try {
+		const composeConverted = await addDomainToCompose(compose, domains);
+		const path = getComposePath(compose);
+
+		if (!composeConverted) {
+			return `
+echo "❌ Error: Compose file not found" >> ${logPath};
+exit 1;
+			`;
+		}
+		if (compose.serverId) {
+			const composeString = dump(composeConverted, { lineWidth: 1000 });
+			const encodedContent = encodeBase64(composeString);
+			return `echo "${encodedContent}" | base64 -d > "${path}";`;
+		}
+	} catch (error) {
+		// @ts-ignore
+		return `echo "❌ Has occured an error: ${error?.message || error}" >> ${logPath};
+exit 1;
+		`;
+	}
+};
+// (node:59875) MaxListenersExceededWarning: Possible EventEmitter memory leak detected. 11 SIGTERM listeners added to [process]. Use emitter.setMaxListeners() to increase limit
+export const addDomainToCompose = async (
+	compose: Compose,
+	domains: Domain[],
+) => {
+	const { appName } = compose;
+
+	let result: ComposeSpecification | null;
+
+	if (compose.serverId) {
+		result = await loadDockerComposeRemote(compose); // aca hay que ir al servidor e ir a traer el compose file al servidor
+	} else {
+		result = await loadDockerCompose(compose);
+	}
+
+	if (!result || domains.length === 0) {
+		return null;
+	}
+
+	if (compose.randomize) {
+		const randomized = randomizeSpecificationFile(result, compose.suffix);
+		result = randomized;
+	}
+
+	for (const domain of domains) {
+		const { serviceName, https } = domain;
+		if (!serviceName) {
+			throw new Error("Service name not found");
+		}
+		if (!result?.services?.[serviceName]) {
+			throw new Error(`The service ${serviceName} not found in the compose`);
+		}
+		if (!result.services[serviceName].labels) {
+			result.services[serviceName].labels = [];
+		}
+
+		const httpLabels = await createDomainLabels(appName, domain, "web");
+		if (https) {
+			const httpsLabels = await createDomainLabels(
+				appName,
+				domain,
+				"websecure",
+			);
+			httpLabels.push(...httpsLabels);
+		}
+
+		const labels = result.services[serviceName].labels;
+
+		if (Array.isArray(labels)) {
+			if (!labels.includes("traefik.enable=true")) {
+				labels.push("traefik.enable=true");
+			}
+			labels.push(...httpLabels);
+		}
+
+		// Add the dokploy-network to the service
+		result.services[serviceName].networks = addDokployNetworkToService(
+			result.services[serviceName].networks,
+		);
+	}
+
+	// Add dokploy-network to the root of the compose file
+	result.networks = addDokployNetworkToRoot(result.networks);
+
+	return result;
+};
+
+export const writeComposeFile = async (
+	compose: Compose,
+	composeSpec: ComposeSpecification,
+) => {
+	const path = getComposePath(compose);
+
+	try {
+		const composeFile = dump(composeSpec, {
+			lineWidth: 1000,
+		});
+		fs.writeFileSync(path, composeFile, "utf8");
+	} catch (e) {
+		console.error("Error saving the YAML config file:", e);
+	}
+};
+
+export const createDomainLabels = async (
+	appName: string,
+	domain: Domain,
+	entrypoint: "web" | "websecure",
+) => {
+	const { host, port, https, uniqueConfigKey, certificateType } = domain;
+	const routerName = `${appName}-${uniqueConfigKey}-${entrypoint}`;
+	const labels = [
+		`traefik.http.routers.${routerName}.rule=Host(\`${host}\`)`,
+		`traefik.http.routers.${routerName}.entrypoints=${entrypoint}`,
+		`traefik.http.services.${routerName}.loadbalancer.server.port=${port}`,
+		`traefik.http.routers.${routerName}.service=${routerName}`,
+	];
+
+	if (entrypoint === "web" && https) {
+		labels.push(
+			`traefik.http.routers.${routerName}.middlewares=redirect-to-https@file`,
+		);
+	}
+
+	if (entrypoint === "websecure") {
+		if (certificateType === "letsencrypt") {
+			labels.push(
+				`traefik.http.routers.${routerName}.tls.certresolver=letsencrypt`,
+			);
+		}
+	}
+
+	return labels;
+};
+
+export const addDokployNetworkToService = (
+	networkService: DefinitionsService["networks"],
+) => {
+	let networks = networkService;
+	const network = "dokploy-network";
+	if (!networks) {
+		networks = [];
+	}
+
+	if (Array.isArray(networks)) {
+		if (!networks.includes(network)) {
+			networks.push(network);
+		}
+	} else if (networks && typeof networks === "object") {
+		if (!(network in networks)) {
+			networks[network] = {};
+		}
+	}
+
+	return networks;
+};
+
+export const addDokployNetworkToRoot = (
+	networkRoot: PropertiesNetworks | undefined,
+) => {
+	let networks = networkRoot;
+	const network = "dokploy-network";
+
+	if (!networks) {
+		networks = {};
+	}
+
+	if (networks[network] || !networks[network]) {
+		networks[network] = {
+			external: true,
+		};
+	}
+
+	return networks;
+};

packages/server/src/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;
+}[];
+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;
+}

packages/server/src/utils/docker/utils.ts

@@ -0,0 +1,525 @@
+import fs from "node:fs";
+import path from "node:path";
+import type { Readable } from "node:stream";
+import { docker, paths } from "@/server/constants";
+import type { ContainerInfo, ResourceRequirements } from "dockerode";
+import { parse } from "dotenv";
+import type { ApplicationNested } from "../builders";
+import type { MariadbNested } from "../databases/mariadb";
+import type { MongoNested } from "../databases/mongo";
+import type { MysqlNested } from "../databases/mysql";
+import type { PostgresNested } from "../databases/postgres";
+import type { RedisNested } from "../databases/redis";
+import { execAsync, execAsyncRemote } from "../process/execAsync";
+import { getRemoteDocker } from "../servers/remote-docker";
+
+interface RegistryAuth {
+	username: string;
+	password: string;
+	serveraddress: string;
+}
+
+export const pullImage = async (
+	dockerImage: string,
+	onData?: (data: any) => void,
+	authConfig?: Partial<RegistryAuth>,
+): Promise<void> => {
+	try {
+		if (!dockerImage) {
+			throw new Error("Docker image not found");
+		}
+
+		await new Promise((resolve, reject) => {
+			docker.pull(dockerImage, { authconfig: authConfig }, (err, stream) => {
+				if (err) {
+					reject(err);
+					return;
+				}
+
+				docker.modem.followProgress(
+					stream as Readable,
+					(err: Error | null, res) => {
+						if (!err) {
+							resolve(res);
+						}
+						if (err) {
+							reject(err);
+						}
+					},
+					(event) => {
+						onData?.(event);
+					},
+				);
+			});
+		});
+	} catch (error) {
+		throw error;
+	}
+};
+
+export const pullRemoteImage = async (
+	dockerImage: string,
+	serverId: string,
+	onData?: (data: any) => void,
+	authConfig?: Partial<RegistryAuth>,
+): Promise<void> => {
+	try {
+		if (!dockerImage) {
+			throw new Error("Docker image not found");
+		}
+
+		const remoteDocker = await getRemoteDocker(serverId);
+
+		await new Promise((resolve, reject) => {
+			remoteDocker.pull(
+				dockerImage,
+				{ authconfig: authConfig },
+				(err, stream) => {
+					if (err) {
+						reject(err);
+						return;
+					}
+
+					remoteDocker.modem.followProgress(
+						stream as Readable,
+						(err: Error | null, res) => {
+							if (!err) {
+								resolve(res);
+							}
+							if (err) {
+								reject(err);
+							}
+						},
+						(event) => {
+							onData?.(event);
+						},
+					);
+				},
+			);
+		});
+	} catch (error) {
+		throw error;
+	}
+};
+
+export const containerExists = async (containerName: string) => {
+	const container = docker.getContainer(containerName);
+	try {
+		await container.inspect();
+		return true;
+	} catch (error) {
+		return false;
+	}
+};
+
+export const stopService = async (appName: string) => {
+	try {
+		await execAsync(`docker service scale ${appName}=0 `);
+	} catch (error) {
+		console.error(error);
+		return error;
+	}
+};
+
+export const stopServiceRemote = async (serverId: string, appName: string) => {
+	try {
+		await execAsyncRemote(serverId, `docker service scale ${appName}=0 `);
+	} catch (error) {
+		console.error(error);
+		return error;
+	}
+};
+
+export const getContainerByName = (name: string): Promise<ContainerInfo> => {
+	const opts = {
+		limit: 1,
+		filters: {
+			name: [name],
+		},
+	};
+	return new Promise((resolve, reject) => {
+		docker.listContainers(opts, (err, containers) => {
+			if (err) {
+				reject(err);
+			} else if (containers?.length === 0) {
+				reject(new Error(`No container found with name: ${name}`));
+			} else if (containers && containers?.length > 0 && containers[0]) {
+				resolve(containers[0]);
+			}
+		});
+	});
+};
+export const cleanUpUnusedImages = async (serverId?: string) => {
+	try {
+		if (serverId) {
+			await execAsyncRemote(serverId, "docker image prune --all --force");
+		} else {
+			await execAsync("docker image prune --all --force");
+		}
+	} catch (error) {
+		console.error(error);
+		throw error;
+	}
+};
+
+export const cleanStoppedContainers = async (serverId?: string) => {
+	try {
+		if (serverId) {
+			await execAsyncRemote(serverId, "docker container prune --force");
+		} else {
+			await execAsync("docker container prune --force");
+		}
+	} catch (error) {
+		console.error(error);
+		throw error;
+	}
+};
+
+export const cleanUpUnusedVolumes = async (serverId?: string) => {
+	try {
+		if (serverId) {
+			await execAsyncRemote(serverId, "docker volume prune --all --force");
+		} else {
+			await execAsync("docker volume prune --all --force");
+		}
+	} catch (error) {
+		console.error(error);
+		throw error;
+	}
+};
+
+export const cleanUpInactiveContainers = async () => {
+	try {
+		const containers = await docker.listContainers({ all: true });
+		const inactiveContainers = containers.filter(
+			(container) => container.State !== "running",
+		);
+
+		for (const container of inactiveContainers) {
+			await docker.getContainer(container.Id).remove({ force: true });
+			console.log(`Cleaning up inactive container: ${container.Id}`);
+		}
+	} catch (error) {
+		console.error("Error cleaning up inactive containers:", error);
+		throw error;
+	}
+};
+
+export const cleanUpDockerBuilder = async (serverId?: string) => {
+	if (serverId) {
+		await execAsyncRemote(serverId, "docker builder prune --all --force");
+	} else {
+		await execAsync("docker builder prune --all --force");
+	}
+};
+
+export const cleanUpSystemPrune = async (serverId?: string) => {
+	if (serverId) {
+		await execAsyncRemote(
+			serverId,
+			"docker system prune --all --force --volumes",
+		);
+	} else {
+		await execAsync("docker system prune --all --force --volumes");
+	}
+};
+
+export const startService = async (appName: string) => {
+	try {
+		await execAsync(`docker service scale ${appName}=1 `);
+	} catch (error) {
+		console.error(error);
+		throw error;
+	}
+};
+
+export const startServiceRemote = async (serverId: string, appName: string) => {
+	try {
+		await execAsyncRemote(serverId, `docker service scale ${appName}=1 `);
+	} catch (error) {
+		console.error(error);
+		throw error;
+	}
+};
+
+export const removeService = async (
+	appName: string,
+	serverId?: string | null,
+) => {
+	try {
+		const command = `docker service rm ${appName}`;
+		if (serverId) {
+			await execAsyncRemote(serverId, command);
+		} else {
+			await execAsync(command);
+		}
+	} catch (error) {
+		return error;
+	}
+};
+
+export const prepareEnvironmentVariables = (env: string | null) =>
+	Object.entries(parse(env ?? "")).map(([key, value]) => `${key}=${value}`);
+
+export const prepareBuildArgs = (input: string | null) => {
+	const pairs = (input ?? "").split("\n");
+
+	const jsonObject: Record<string, string> = {};
+
+	for (const pair of pairs) {
+		const [key, value] = pair.split("=");
+		if (key && value) {
+			jsonObject[key] = value;
+		}
+	}
+
+	return jsonObject;
+};
+
+export const generateVolumeMounts = (mounts: ApplicationNested["mounts"]) => {
+	if (!mounts || mounts.length === 0) {
+		return [];
+	}
+
+	return mounts
+		.filter((mount) => mount.type === "volume")
+		.map((mount) => ({
+			Type: "volume" as const,
+			Source: mount.volumeName || "",
+			Target: mount.mountPath,
+		}));
+};
+
+type Resources = {
+	memoryLimit: number | null;
+	memoryReservation: number | null;
+	cpuLimit: number | null;
+	cpuReservation: number | null;
+};
+export const calculateResources = ({
+	memoryLimit,
+	memoryReservation,
+	cpuLimit,
+	cpuReservation,
+}: Resources): ResourceRequirements => {
+	return {
+		Limits: {
+			MemoryBytes: memoryLimit ? memoryLimit * 1024 * 1024 : undefined,
+			NanoCPUs: memoryLimit ? (cpuLimit || 1) * 1000 * 1000 * 1000 : undefined,
+		},
+		Reservations: {
+			MemoryBytes: memoryLimit
+				? (memoryReservation || 1) * 1024 * 1024
+				: undefined,
+			NanoCPUs: memoryLimit
+				? (cpuReservation || 1) * 1000 * 1000 * 1000
+				: undefined,
+		},
+	};
+};
+
+export const generateConfigContainer = (application: ApplicationNested) => {
+	const {
+		healthCheckSwarm,
+		restartPolicySwarm,
+		placementSwarm,
+		updateConfigSwarm,
+		rollbackConfigSwarm,
+		modeSwarm,
+		labelsSwarm,
+		replicas,
+		mounts,
+		networkSwarm,
+	} = application;
+
+	const haveMounts = mounts.length > 0;
+
+	return {
+		...(healthCheckSwarm && {
+			HealthCheck: healthCheckSwarm,
+		}),
+		...(restartPolicySwarm
+			? {
+					RestartPolicy: restartPolicySwarm,
+				}
+			: {}),
+		...(placementSwarm
+			? {
+					Placement: placementSwarm,
+				}
+			: {
+					// if app have mounts keep manager as constraint
+					Placement: {
+						Constraints: haveMounts ? ["node.role==manager"] : [],
+					},
+				}),
+		...(labelsSwarm && {
+			Labels: labelsSwarm,
+		}),
+		...(modeSwarm
+			? {
+					Mode: modeSwarm,
+				}
+			: {
+					// use replicas value if no modeSwarm provided
+					Mode: {
+						Replicated: {
+							Replicas: replicas,
+						},
+					},
+				}),
+		...(rollbackConfigSwarm && {
+			RollbackConfig: rollbackConfigSwarm,
+		}),
+		...(updateConfigSwarm
+			? { UpdateConfig: updateConfigSwarm }
+			: {
+					// default config if no updateConfigSwarm provided
+					UpdateConfig: {
+						Parallelism: 1,
+						Order: "start-first",
+					},
+				}),
+		...(networkSwarm
+			? {
+					Networks: networkSwarm,
+				}
+			: {
+					Networks: [{ Target: "dokploy-network" }],
+				}),
+	};
+};
+
+export const generateBindMounts = (mounts: ApplicationNested["mounts"]) => {
+	if (!mounts || mounts.length === 0) {
+		return [];
+	}
+
+	return mounts
+		.filter((mount) => mount.type === "bind")
+		.map((mount) => ({
+			Type: "bind" as const,
+			Source: mount.hostPath || "",
+			Target: mount.mountPath,
+		}));
+};
+
+export const generateFileMounts = (
+	appName: string,
+	service:
+		| ApplicationNested
+		| MongoNested
+		| MariadbNested
+		| MysqlNested
+		| PostgresNested
+		| RedisNested,
+) => {
+	const { mounts } = service;
+	const { APPLICATIONS_PATH } = paths(!!service.serverId);
+	if (!mounts || mounts.length === 0) {
+		return [];
+	}
+
+	return mounts
+		.filter((mount) => mount.type === "file")
+		.map((mount) => {
+			const fileName = mount.filePath;
+			const absoluteBasePath = path.resolve(APPLICATIONS_PATH);
+			const directory = path.join(absoluteBasePath, appName, "files");
+			const sourcePath = path.join(directory, fileName || "");
+			return {
+				Type: "bind" as const,
+				Source: sourcePath,
+				Target: mount.mountPath,
+			};
+		});
+};
+
+export const createFile = async (
+	outputPath: string,
+	filePath: string,
+	content: string,
+) => {
+	try {
+		const fullPath = path.join(outputPath, filePath);
+		if (fullPath.endsWith(path.sep) || filePath.endsWith("/")) {
+			fs.mkdirSync(fullPath, { recursive: true });
+			return;
+		}
+
+		const directory = path.dirname(fullPath);
+		fs.mkdirSync(directory, { recursive: true });
+		fs.writeFileSync(fullPath, content || "");
+	} catch (error) {
+		throw error;
+	}
+};
+export const encodeBase64 = (content: string) =>
+	Buffer.from(content, "utf-8").toString("base64");
+
+export const getCreateFileCommand = (
+	outputPath: string,
+	filePath: string,
+	content: string,
+) => {
+	const fullPath = path.join(outputPath, filePath);
+	if (fullPath.endsWith(path.sep) || filePath.endsWith("/")) {
+		return `mkdir -p ${fullPath};`;
+	}
+
+	const directory = path.dirname(fullPath);
+	const encodedContent = encodeBase64(content);
+	return `
+		mkdir -p ${directory};
+		echo "${encodedContent}" | base64 -d > "${fullPath}";
+	`;
+};
+
+export const getServiceContainer = async (appName: string) => {
+	try {
+		const filter = {
+			status: ["running"],
+			label: [`com.docker.swarm.service.name=${appName}`],
+		};
+
+		const containers = await docker.listContainers({
+			filters: JSON.stringify(filter),
+		});
+
+		if (containers.length === 0 || !containers[0]) {
+			throw new Error(`No container found with name: ${appName}`);
+		}
+
+		const container = containers[0];
+
+		return container;
+	} catch (error) {
+		throw error;
+	}
+};
+
+export const getRemoteServiceContainer = async (
+	serverId: string,
+	appName: string,
+) => {
+	try {
+		const filter = {
+			status: ["running"],
+			label: [`com.docker.swarm.service.name=${appName}`],
+		};
+		const remoteDocker = await getRemoteDocker(serverId);
+		const containers = await remoteDocker.listContainers({
+			filters: JSON.stringify(filter),
+		});
+
+		if (containers.length === 0 || !containers[0]) {
+			throw new Error(`No container found with name: ${appName}`);
+		}
+
+		const container = containers[0];
+
+		return container;
+	} catch (error) {
+		throw error;
+	}
+};