refactor: rename builders to server

packages/server/src/auth/auth.ts

@@ -0,0 +1,119 @@
+import { webcrypto } from "node:crypto";
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { findAdminByAuthId } from "@/server/services/admin";
+import { findUserByAuthId } from "@/server/services/user";
+import { DrizzlePostgreSQLAdapter } from "@lucia-auth/adapter-drizzle";
+import { TimeSpan } from "lucia";
+import { Lucia } from "lucia/dist/core.js";
+import type { Session, User } from "lucia/dist/core.js";
+import { db } from "../db";
+import { type DatabaseUser, auth, sessionTable } from "../db/schema";
+
+globalThis.crypto = webcrypto as Crypto;
+export const adapter = new DrizzlePostgreSQLAdapter(db, sessionTable, auth);
+
+export const lucia = new Lucia(adapter, {
+	sessionCookie: {
+		attributes: {
+			secure: false,
+		},
+	},
+	sessionExpiresIn: new TimeSpan(1, "d"),
+	getUserAttributes: (attributes) => {
+		return {
+			email: attributes.email,
+			rol: attributes.rol,
+			secret: attributes.secret !== null,
+			adminId: attributes.adminId,
+		};
+	},
+});
+
+declare module "lucia" {
+	interface Register {
+		Lucia: typeof lucia;
+		DatabaseUserAttributes: Omit<DatabaseUser, "id"> & {
+			authId: string;
+			adminId: string;
+		};
+	}
+}
+
+export type ReturnValidateToken = Promise<{
+	user: (User & { authId: string; adminId: string }) | null;
+	session: Session | null;
+}>;
+
+export async function validateRequest(
+	req: IncomingMessage,
+	res: ServerResponse,
+): ReturnValidateToken {
+	const sessionId = lucia.readSessionCookie(req.headers.cookie ?? "");
+
+	if (!sessionId) {
+		return {
+			user: null,
+			session: null,
+		};
+	}
+	const result = await lucia.validateSession(sessionId);
+	if (result?.session?.fresh) {
+		res.appendHeader(
+			"Set-Cookie",
+			lucia.createSessionCookie(result.session.id).serialize(),
+		);
+	}
+	if (!result.session) {
+		res.appendHeader(
+			"Set-Cookie",
+			lucia.createBlankSessionCookie().serialize(),
+		);
+	}
+	if (result.user) {
+		try {
+			if (result.user?.rol === "admin") {
+				const admin = await findAdminByAuthId(result.user.id);
+				result.user.adminId = admin.adminId;
+			} else if (result.user?.rol === "user") {
+				const userResult = await findUserByAuthId(result.user.id);
+				result.user.adminId = userResult.adminId;
+			}
+		} catch (error) {
+			return {
+				user: null,
+				session: null,
+			};
+		}
+	}
+
+	return {
+		session: result.session,
+		...((result.user && {
+			user: {
+				authId: result.user.id,
+				email: result.user.email,
+				rol: result.user.rol,
+				id: result.user.id,
+				secret: result.user.secret,
+				adminId: result.user.adminId,
+			},
+		}) || {
+			user: null,
+		}),
+	};
+}
+
+export async function validateWebSocketRequest(
+	req: IncomingMessage,
+): Promise<{ user: User; session: Session } | { user: null; session: null }> {
+	const sessionId = lucia.readSessionCookie(req.headers.cookie ?? "");
+
+	if (!sessionId) {
+		return {
+			user: null,
+			session: null,
+		};
+	}
+	const result = await lucia.validateSession(sessionId);
+	return result;
+}

packages/server/src/auth/random-password.ts

@@ -0,0 +1,20 @@
+import bcrypt from "bcrypt";
+
+export const generateRandomPassword = async () => {
+	const passwordLength = 16;
+
+	const characters =
+		"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+
+	let randomPassword = "";
+	for (let i = 0; i < passwordLength; i++) {
+		randomPassword += characters.charAt(
+			Math.floor(Math.random() * characters.length),
+		);
+	}
+
+	const saltRounds = 10;
+
+	const hashedPassword = await bcrypt.hash(randomPassword, saltRounds);
+	return { randomPassword, hashedPassword };
+};

packages/server/src/auth/token.ts

@@ -0,0 +1,61 @@
+import type { IncomingMessage } from "node:http";
+import { TimeSpan } from "lucia";
+import { Lucia } from "lucia/dist/core.js";
+import { findAdminByAuthId } from "../services/admin";
+import { findUserByAuthId } from "../services/user";
+import { type ReturnValidateToken, adapter } from "./auth";
+
+export const luciaToken = new Lucia(adapter, {
+	sessionCookie: {
+		attributes: {
+			secure: false,
+		},
+	},
+	sessionExpiresIn: new TimeSpan(365, "d"),
+	getUserAttributes: (attributes) => {
+		return {
+			email: attributes.email,
+			rol: attributes.rol,
+			secret: attributes.secret !== null,
+		};
+	},
+});
+
+export const validateBearerToken = async (
+	req: IncomingMessage,
+): ReturnValidateToken => {
+	const authorizationHeader = req.headers.authorization;
+	const sessionId = luciaToken.readBearerToken(authorizationHeader ?? "");
+	if (!sessionId) {
+		return {
+			user: null,
+			session: null,
+		};
+	}
+	const result = await luciaToken.validateSession(sessionId);
+
+	if (result.user) {
+		if (result.user?.rol === "admin") {
+			const admin = await findAdminByAuthId(result.user.id);
+			result.user.adminId = admin.adminId;
+		} else if (result.user?.rol === "user") {
+			const userResult = await findUserByAuthId(result.user.id);
+			result.user.adminId = userResult.adminId;
+		}
+	}
+	return {
+		session: result.session,
+		...((result.user && {
+			user: {
+				adminId: result.user.adminId,
+				authId: result.user.id,
+				email: result.user.email,
+				rol: result.user.rol,
+				id: result.user.id,
+				secret: result.user.secret,
+			},
+		}) || {
+			user: null,
+		}),
+	};
+};

packages/server/src/constants/index.ts

@@ -0,0 +1,39 @@
+import path from "node:path";
+import Docker from "dockerode";
+
+export const IS_CLOUD = process.env.IS_CLOUD === "true";
+export const docker = new Docker();
+
+export const paths = (isServer = false) => {
+	if (isServer) {
+		const BASE_PATH = "/etc/dokploy";
+		return {
+			BASE_PATH,
+			MAIN_TRAEFIK_PATH: `${BASE_PATH}/traefik`,
+			DYNAMIC_TRAEFIK_PATH: `${BASE_PATH}/traefik/dynamic`,
+			LOGS_PATH: `${BASE_PATH}/logs`,
+			APPLICATIONS_PATH: `${BASE_PATH}/applications`,
+			COMPOSE_PATH: `${BASE_PATH}/compose`,
+			SSH_PATH: `${BASE_PATH}/ssh`,
+			CERTIFICATES_PATH: `${BASE_PATH}/certificates`,
+			MONITORING_PATH: `${BASE_PATH}/monitoring`,
+			REGISTRY_PATH: `${BASE_PATH}/registry`,
+		};
+	}
+	const BASE_PATH =
+		process.env.NODE_ENV === "production"
+			? "/etc/dokploy"
+			: path.join(process.cwd(), ".docker");
+	return {
+		BASE_PATH,
+		MAIN_TRAEFIK_PATH: `${BASE_PATH}/traefik`,
+		DYNAMIC_TRAEFIK_PATH: `${BASE_PATH}/traefik/dynamic`,
+		LOGS_PATH: `${BASE_PATH}/logs`,
+		APPLICATIONS_PATH: `${BASE_PATH}/applications`,
+		COMPOSE_PATH: `${BASE_PATH}/compose`,
+		SSH_PATH: `${BASE_PATH}/ssh`,
+		CERTIFICATES_PATH: `${BASE_PATH}/certificates`,
+		MONITORING_PATH: `${BASE_PATH}/monitoring`,
+		REGISTRY_PATH: `${BASE_PATH}/registry`,
+	};
+};

packages/server/src/db/drizzle.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig } from "drizzle-kit";
+
+export default defineConfig({
+	schema: "./server/db/schema/index.ts",
+	dialect: "postgresql",
+	dbCredentials: {
+		url: process.env.DATABASE_URL || "",
+	},
+	out: "drizzle",
+	migrations: {
+		table: "migrations",
+		schema: "public",
+	},
+});

packages/server/src/db/index.ts

@@ -0,0 +1,20 @@
+import { type PostgresJsDatabase, drizzle } from "drizzle-orm/postgres-js";
+import postgres from "postgres";
+import * as schema from "./schema";
+declare global {
+	var db: PostgresJsDatabase<typeof schema> | undefined;
+}
+
+export let db: PostgresJsDatabase<typeof schema>;
+if (process.env.NODE_ENV === "production") {
+	db = drizzle(postgres(process.env.DATABASE_URL || ""), {
+		schema,
+	});
+} else {
+	if (!global.db)
+		global.db = drizzle(postgres(process.env.DATABASE_URL || ""), {
+			schema,
+		});
+
+	db = global.db;
+}

packages/server/src/db/migration.ts

@@ -0,0 +1,21 @@
+// import { drizzle } from "drizzle-orm/postgres-js";
+// import { migrate } from "drizzle-orm/postgres-js/migrator";
+// import postgres from "postgres";
+
+// const connectionString = process.env.DATABASE_URL || "";
+
+// const sql = postgres(connectionString, { max: 1 });
+// const db = drizzle(sql);
+
+// export const migration = async () =>
+// 	await migrate(db, { migrationsFolder: "drizzle" })
+// 		.then(() => {
+// 			console.log("Migration complete");
+// 			sql.end();
+// 		})
+// 		.catch((error) => {
+// 			console.log("Migration failed", error);
+// 		})
+// 		.finally(() => {
+// 			sql.end();
+// 		});

packages/server/src/db/reset.ts

@@ -0,0 +1,23 @@
+// import { sql } from "drizzle-orm";
+// // Credits to Louistiti from Drizzle Discord: https://discord.com/channels/1043890932593987624/1130802621750448160/1143083373535973406
+// import { drizzle } from "drizzle-orm/postgres-js";
+// import postgres from "postgres";
+
+// const connectionString = process.env.DATABASE_URL || "";
+
+// const pg = postgres(connectionString, { max: 1 });
+// const db = drizzle(pg);
+
+// const clearDb = async (): Promise<void> => {
+// 	try {
+// 		const tablesQuery = sql<string>`DROP SCHEMA public CASCADE; CREATE SCHEMA public; DROP schema drizzle CASCADE;`;
+// 		const tables = await db.execute(tablesQuery);
+// 		console.log(tables);
+// 		await pg.end();
+// 	} catch (error) {
+// 		console.error("Error to clean database", error);
+// 	} finally {
+// 	}
+// };
+
+// clearDb();

packages/server/src/db/schema/admin.ts

@@ -0,0 +1,108 @@
+import { relations } from "drizzle-orm";
+import { boolean, pgTable, text } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { auth } from "./auth";
+import { registry } from "./registry";
+import { certificateType } from "./shared";
+import { sshKeys } from "./ssh-key";
+import { users } from "./user";
+
+export const admins = pgTable("admin", {
+	adminId: text("adminId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	serverIp: text("serverIp"),
+	certificateType: certificateType("certificateType").notNull().default("none"),
+	host: text("host"),
+	letsEncryptEmail: text("letsEncryptEmail"),
+	sshPrivateKey: text("sshPrivateKey"),
+	enableDockerCleanup: boolean("enableDockerCleanup").notNull().default(false),
+	enableLogRotation: boolean("enableLogRotation").notNull().default(false),
+	authId: text("authId")
+		.notNull()
+		.references(() => auth.id, { onDelete: "cascade" }),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+});
+
+export const adminsRelations = relations(admins, ({ one, many }) => ({
+	auth: one(auth, {
+		fields: [admins.authId],
+		references: [auth.id],
+	}),
+	users: many(users),
+	registry: many(registry),
+	sshKeys: many(sshKeys),
+}));
+
+const createSchema = createInsertSchema(admins, {
+	adminId: z.string(),
+	enableDockerCleanup: z.boolean().optional(),
+	sshPrivateKey: z.string().optional(),
+	certificateType: z.enum(["letsencrypt", "none"]).default("none"),
+	serverIp: z.string().optional(),
+});
+
+export const apiSaveSSHKey = createSchema
+	.pick({
+		sshPrivateKey: true,
+	})
+	.required();
+
+export const apiAssignDomain = createSchema
+	.pick({
+		letsEncryptEmail: true,
+		host: true,
+		certificateType: true,
+	})
+	.required();
+
+export const apiUpdateDockerCleanup = createSchema
+	.pick({
+		enableDockerCleanup: true,
+	})
+	.required()
+	.extend({
+		serverId: z.string().optional(),
+	});
+
+export const apiTraefikConfig = z.object({
+	traefikConfig: z.string().min(1),
+});
+
+export const apiModifyTraefikConfig = z.object({
+	path: z.string().min(1),
+	traefikConfig: z.string().min(1),
+	serverId: z.string().optional(),
+});
+export const apiReadTraefikConfig = z.object({
+	path: z.string().min(1),
+	serverId: z.string().optional(),
+});
+
+export const apiEnableDashboard = z.object({
+	enableDashboard: z.boolean().optional(),
+	serverId: z.string().optional(),
+});
+
+export const apiServerSchema = z
+	.object({
+		serverId: z.string().optional(),
+	})
+	.optional();
+
+export const apiReadStatsLogs = z.object({
+	page: z
+		.object({
+			pageIndex: z.number(),
+			pageSize: z.number(),
+		})
+		.optional(),
+	status: z.string().array().optional(),
+	search: z.string().optional(),
+	sort: z.object({ id: z.string(), desc: z.boolean() }).optional(),
+});

packages/server/src/db/schema/application.ts

@@ -0,0 +1,490 @@
+import { relations } from "drizzle-orm";
+import {
+	boolean,
+	integer,
+	json,
+	pgEnum,
+	pgTable,
+	text,
+} from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { bitbucket } from "./bitbucket";
+import { deployments } from "./deployment";
+import { domains } from "./domain";
+import { github } from "./github";
+import { gitlab } from "./gitlab";
+import { mounts } from "./mount";
+import { ports } from "./port";
+import { projects } from "./project";
+import { redirects } from "./redirects";
+import { registry } from "./registry";
+import { security } from "./security";
+import { server } from "./server";
+import { applicationStatus } from "./shared";
+import { sshKeys } from "./ssh-key";
+import { generateAppName } from "./utils";
+
+export const sourceType = pgEnum("sourceType", [
+	"docker",
+	"git",
+	"github",
+	"gitlab",
+	"bitbucket",
+	"drop",
+]);
+
+export const buildType = pgEnum("buildType", [
+	"dockerfile",
+	"heroku_buildpacks",
+	"paketo_buildpacks",
+	"nixpacks",
+	"static",
+]);
+
+// TODO: refactor this types
+export interface HealthCheckSwarm {
+	Test?: string[] | undefined;
+	Interval?: number | undefined;
+	Timeout?: number | undefined;
+	StartPeriod?: number | undefined;
+	Retries?: number | undefined;
+}
+
+export interface RestartPolicySwarm {
+	Condition?: string | undefined;
+	Delay?: number | undefined;
+	MaxAttempts?: number | undefined;
+	Window?: number | undefined;
+}
+
+export interface PlacementSwarm {
+	Constraints?: string[] | undefined;
+	Preferences?: Array<{ Spread: { SpreadDescriptor: string } }> | undefined;
+	MaxReplicas?: number | undefined;
+	Platforms?:
+		| Array<{
+				Architecture: string;
+				OS: string;
+		  }>
+		| undefined;
+}
+
+export interface UpdateConfigSwarm {
+	Parallelism: number;
+	Delay?: number | undefined;
+	FailureAction?: string | undefined;
+	Monitor?: number | undefined;
+	MaxFailureRatio?: number | undefined;
+	Order: string;
+}
+
+export interface ServiceModeSwarm {
+	Replicated?: { Replicas?: number | undefined } | undefined;
+	Global?: {} | undefined;
+	ReplicatedJob?:
+		| {
+				MaxConcurrent?: number | undefined;
+				TotalCompletions?: number | undefined;
+		  }
+		| undefined;
+	GlobalJob?: {} | undefined;
+}
+
+export interface NetworkSwarm {
+	Target?: string | undefined;
+	Aliases?: string[] | undefined;
+	DriverOpts?: { [key: string]: string } | undefined;
+}
+
+export interface LabelsSwarm {
+	[name: string]: string;
+}
+
+export const applications = pgTable("application", {
+	applicationId: text("applicationId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	name: text("name").notNull(),
+	appName: text("appName")
+		.notNull()
+		.$defaultFn(() => generateAppName("app"))
+		.unique(),
+	description: text("description"),
+	env: text("env"),
+	buildArgs: text("buildArgs"),
+	memoryReservation: integer("memoryReservation"),
+	memoryLimit: integer("memoryLimit"),
+	cpuReservation: integer("cpuReservation"),
+	cpuLimit: integer("cpuLimit"),
+	title: text("title"),
+	enabled: boolean("enabled"),
+	subtitle: text("subtitle"),
+	command: text("command"),
+	refreshToken: text("refreshToken").$defaultFn(() => nanoid()),
+	sourceType: sourceType("sourceType").notNull().default("github"),
+	// Github
+	repository: text("repository"),
+	owner: text("owner"),
+	branch: text("branch"),
+	buildPath: text("buildPath").default("/"),
+	autoDeploy: boolean("autoDeploy").$defaultFn(() => true),
+	// Gitlab
+	gitlabProjectId: integer("gitlabProjectId"),
+	gitlabRepository: text("gitlabRepository"),
+	gitlabOwner: text("gitlabOwner"),
+	gitlabBranch: text("gitlabBranch"),
+	gitlabBuildPath: text("gitlabBuildPath").default("/"),
+	gitlabPathNamespace: text("gitlabPathNamespace"),
+	// Bitbucket
+	bitbucketRepository: text("bitbucketRepository"),
+	bitbucketOwner: text("bitbucketOwner"),
+	bitbucketBranch: text("bitbucketBranch"),
+	bitbucketBuildPath: text("bitbucketBuildPath").default("/"),
+	// Docker
+	username: text("username"),
+	password: text("password"),
+	dockerImage: text("dockerImage"),
+	// Git
+	customGitUrl: text("customGitUrl"),
+	customGitBranch: text("customGitBranch"),
+	customGitBuildPath: text("customGitBuildPath"),
+	customGitSSHKeyId: text("customGitSSHKeyId").references(
+		() => sshKeys.sshKeyId,
+		{
+			onDelete: "set null",
+		},
+	),
+	dockerfile: text("dockerfile"),
+	dockerContextPath: text("dockerContextPath"),
+	dockerBuildStage: text("dockerBuildStage"),
+	// Drop
+	dropBuildPath: text("dropBuildPath"),
+	// Docker swarm json
+	healthCheckSwarm: json("healthCheckSwarm").$type<HealthCheckSwarm>(),
+	restartPolicySwarm: json("restartPolicySwarm").$type<RestartPolicySwarm>(),
+	placementSwarm: json("placementSwarm").$type<PlacementSwarm>(),
+	updateConfigSwarm: json("updateConfigSwarm").$type<UpdateConfigSwarm>(),
+	rollbackConfigSwarm: json("rollbackConfigSwarm").$type<UpdateConfigSwarm>(),
+	modeSwarm: json("modeSwarm").$type<ServiceModeSwarm>(),
+	labelsSwarm: json("labelsSwarm").$type<LabelsSwarm>(),
+	networkSwarm: json("networkSwarm").$type<NetworkSwarm[]>(),
+	//
+	replicas: integer("replicas").default(1).notNull(),
+	applicationStatus: applicationStatus("applicationStatus")
+		.notNull()
+		.default("idle"),
+	buildType: buildType("buildType").notNull().default("nixpacks"),
+	publishDirectory: text("publishDirectory"),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+	registryId: text("registryId").references(() => registry.registryId, {
+		onDelete: "set null",
+	}),
+	projectId: text("projectId")
+		.notNull()
+		.references(() => projects.projectId, { onDelete: "cascade" }),
+	githubId: text("githubId").references(() => github.githubId, {
+		onDelete: "set null",
+	}),
+	gitlabId: text("gitlabId").references(() => gitlab.gitlabId, {
+		onDelete: "set null",
+	}),
+	bitbucketId: text("bitbucketId").references(() => bitbucket.bitbucketId, {
+		onDelete: "set null",
+	}),
+	serverId: text("serverId").references(() => server.serverId, {
+		onDelete: "cascade",
+	}),
+});
+
+export const applicationsRelations = relations(
+	applications,
+	({ one, many }) => ({
+		project: one(projects, {
+			fields: [applications.projectId],
+			references: [projects.projectId],
+		}),
+		deployments: many(deployments),
+		customGitSSHKey: one(sshKeys, {
+			fields: [applications.customGitSSHKeyId],
+			references: [sshKeys.sshKeyId],
+		}),
+		domains: many(domains),
+		mounts: many(mounts),
+		redirects: many(redirects),
+		security: many(security),
+		ports: many(ports),
+		registry: one(registry, {
+			fields: [applications.registryId],
+			references: [registry.registryId],
+		}),
+		github: one(github, {
+			fields: [applications.githubId],
+			references: [github.githubId],
+		}),
+		gitlab: one(gitlab, {
+			fields: [applications.gitlabId],
+			references: [gitlab.gitlabId],
+		}),
+		bitbucket: one(bitbucket, {
+			fields: [applications.bitbucketId],
+			references: [bitbucket.bitbucketId],
+		}),
+		server: one(server, {
+			fields: [applications.serverId],
+			references: [server.serverId],
+		}),
+	}),
+);
+
+const HealthCheckSwarmSchema = z
+	.object({
+		Test: z.array(z.string()).optional(),
+		Interval: z.number().optional(),
+		Timeout: z.number().optional(),
+		StartPeriod: z.number().optional(),
+		Retries: z.number().optional(),
+	})
+	.strict();
+
+const RestartPolicySwarmSchema = z
+	.object({
+		Condition: z.string().optional(),
+		Delay: z.number().optional(),
+		MaxAttempts: z.number().optional(),
+		Window: z.number().optional(),
+	})
+	.strict();
+
+const PreferenceSchema = z
+	.object({
+		Spread: z.object({
+			SpreadDescriptor: z.string(),
+		}),
+	})
+	.strict();
+
+const PlatformSchema = z
+	.object({
+		Architecture: z.string(),
+		OS: z.string(),
+	})
+	.strict();
+
+const PlacementSwarmSchema = z
+	.object({
+		Constraints: z.array(z.string()).optional(),
+		Preferences: z.array(PreferenceSchema).optional(),
+		MaxReplicas: z.number().optional(),
+		Platforms: z.array(PlatformSchema).optional(),
+	})
+	.strict();
+
+const UpdateConfigSwarmSchema = z
+	.object({
+		Parallelism: z.number(),
+		Delay: z.number().optional(),
+		FailureAction: z.string().optional(),
+		Monitor: z.number().optional(),
+		MaxFailureRatio: z.number().optional(),
+		Order: z.string(),
+	})
+	.strict();
+
+const ReplicatedSchema = z
+	.object({
+		Replicas: z.number().optional(),
+	})
+	.strict();
+
+const ReplicatedJobSchema = z
+	.object({
+		MaxConcurrent: z.number().optional(),
+		TotalCompletions: z.number().optional(),
+	})
+	.strict();
+
+const ServiceModeSwarmSchema = z
+	.object({
+		Replicated: ReplicatedSchema.optional(),
+		Global: z.object({}).optional(),
+		ReplicatedJob: ReplicatedJobSchema.optional(),
+		GlobalJob: z.object({}).optional(),
+	})
+	.strict();
+
+const NetworkSwarmSchema = z.array(
+	z
+		.object({
+			Target: z.string().optional(),
+			Aliases: z.array(z.string()).optional(),
+			DriverOpts: z.object({}).optional(),
+		})
+		.strict(),
+);
+
+const LabelsSwarmSchema = z.record(z.string());
+
+const createSchema = createInsertSchema(applications, {
+	appName: z.string(),
+	createdAt: z.string(),
+	applicationId: z.string(),
+	autoDeploy: z.boolean(),
+	env: z.string().optional(),
+	buildArgs: z.string().optional(),
+	name: z.string().min(1),
+	description: z.string().optional(),
+	memoryReservation: z.number().optional(),
+	memoryLimit: z.number().optional(),
+	cpuReservation: z.number().optional(),
+	cpuLimit: z.number().optional(),
+	title: z.string().optional(),
+	enabled: z.boolean().optional(),
+	subtitle: z.string().optional(),
+	dockerImage: z.string().optional(),
+	username: z.string().optional(),
+	password: z.string().optional(),
+	customGitSSHKeyId: z.string().optional(),
+	repository: z.string().optional(),
+	dockerfile: z.string().optional(),
+	branch: z.string().optional(),
+	customGitBranch: z.string().optional(),
+	customGitBuildPath: z.string().optional(),
+	customGitUrl: z.string().optional(),
+	buildPath: z.string().optional(),
+	projectId: z.string(),
+	sourceType: z.enum(["github", "docker", "git"]).optional(),
+	applicationStatus: z.enum(["idle", "running", "done", "error"]),
+	buildType: z.enum([
+		"dockerfile",
+		"heroku_buildpacks",
+		"paketo_buildpacks",
+		"nixpacks",
+		"static",
+	]),
+	publishDirectory: z.string().optional(),
+	owner: z.string(),
+	healthCheckSwarm: HealthCheckSwarmSchema.nullable(),
+	restartPolicySwarm: RestartPolicySwarmSchema.nullable(),
+	placementSwarm: PlacementSwarmSchema.nullable(),
+	updateConfigSwarm: UpdateConfigSwarmSchema.nullable(),
+	rollbackConfigSwarm: UpdateConfigSwarmSchema.nullable(),
+	modeSwarm: ServiceModeSwarmSchema.nullable(),
+	labelsSwarm: LabelsSwarmSchema.nullable(),
+	networkSwarm: NetworkSwarmSchema.nullable(),
+});
+
+export const apiCreateApplication = createSchema.pick({
+	name: true,
+	appName: true,
+	description: true,
+	projectId: true,
+	serverId: true,
+});
+
+export const apiFindOneApplication = createSchema
+	.pick({
+		applicationId: true,
+	})
+	.required();
+
+export const apiReloadApplication = createSchema
+	.pick({
+		appName: true,
+		applicationId: true,
+	})
+	.required();
+
+export const apiSaveBuildType = createSchema
+	.pick({
+		applicationId: true,
+		buildType: true,
+		dockerfile: true,
+		dockerContextPath: true,
+		dockerBuildStage: true,
+	})
+	.required()
+	.merge(createSchema.pick({ publishDirectory: true }));
+
+export const apiSaveGithubProvider = createSchema
+	.pick({
+		applicationId: true,
+		repository: true,
+		branch: true,
+		owner: true,
+		buildPath: true,
+		githubId: true,
+	})
+	.required();
+
+export const apiSaveGitlabProvider = createSchema
+	.pick({
+		applicationId: true,
+		gitlabBranch: true,
+		gitlabBuildPath: true,
+		gitlabOwner: true,
+		gitlabRepository: true,
+		gitlabId: true,
+		gitlabProjectId: true,
+		gitlabPathNamespace: true,
+	})
+	.required();
+
+export const apiSaveBitbucketProvider = createSchema
+	.pick({
+		bitbucketBranch: true,
+		bitbucketBuildPath: true,
+		bitbucketOwner: true,
+		bitbucketRepository: true,
+		bitbucketId: true,
+		applicationId: true,
+	})
+	.required();
+
+export const apiSaveDockerProvider = createSchema
+	.pick({
+		dockerImage: true,
+		applicationId: true,
+		username: true,
+		password: true,
+	})
+	.required();
+
+export const apiSaveGitProvider = createSchema
+	.pick({
+		customGitBranch: true,
+		applicationId: true,
+		customGitBuildPath: true,
+		customGitUrl: true,
+	})
+	.required()
+	.merge(
+		createSchema.pick({
+			customGitSSHKeyId: true,
+		}),
+	);
+
+export const apiSaveEnvironmentVariables = createSchema
+	.pick({
+		applicationId: true,
+		env: true,
+		buildArgs: true,
+	})
+	.required();
+
+export const apiFindMonitoringStats = createSchema
+	.pick({
+		appName: true,
+	})
+	.required();
+
+export const apiUpdateApplication = createSchema
+	.partial()
+	.extend({
+		applicationId: z.string().min(1),
+	})
+	.omit({ serverId: true });

packages/server/src/db/schema/auth.ts

@@ -0,0 +1,125 @@
+import { getRandomValues } from "node:crypto";
+import { relations } from "drizzle-orm";
+import { boolean, pgEnum, pgTable, text } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { admins } from "./admin";
+import { users } from "./user";
+
+const randomImages = [
+	"/avatars/avatar-1.png",
+	"/avatars/avatar-2.png",
+	"/avatars/avatar-3.png",
+	"/avatars/avatar-4.png",
+	"/avatars/avatar-5.png",
+	"/avatars/avatar-6.png",
+	"/avatars/avatar-7.png",
+	"/avatars/avatar-8.png",
+	"/avatars/avatar-9.png",
+	"/avatars/avatar-10.png",
+	"/avatars/avatar-11.png",
+	"/avatars/avatar-12.png",
+];
+
+const generateRandomImage = () => {
+	return (
+		randomImages[
+			// @ts-ignore
+			getRandomValues(new Uint32Array(1))[0] % randomImages.length
+		] || "/avatars/avatar-1.png"
+	);
+};
+export type DatabaseUser = typeof auth.$inferSelect;
+export const roles = pgEnum("Roles", ["admin", "user"]);
+
+export const auth = pgTable("auth", {
+	id: text("id")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	email: text("email").notNull().unique(),
+	password: text("password").notNull(),
+	rol: roles("rol").notNull(),
+	image: text("image").$defaultFn(() => generateRandomImage()),
+	secret: text("secret"),
+	token: text("token"),
+	is2FAEnabled: boolean("is2FAEnabled").notNull().default(false),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+});
+
+export const authRelations = relations(auth, ({ many }) => ({
+	admins: many(admins),
+	users: many(users),
+}));
+const createSchema = createInsertSchema(auth, {
+	email: z.string().email(),
+	password: z.string().min(8),
+	rol: z.enum(["admin", "user"]),
+	image: z.string().optional(),
+});
+
+export const apiCreateAdmin = createSchema.pick({
+	email: true,
+	password: true,
+});
+
+export const apiCreateUser = createSchema
+	.pick({
+		password: true,
+		id: true,
+		token: true,
+	})
+	.required()
+	.extend({
+		token: z.string().min(1),
+	});
+
+export const apiLogin = createSchema
+	.pick({
+		email: true,
+		password: true,
+	})
+	.required();
+
+export const apiUpdateAuth = createSchema.partial().extend({
+	email: z.string().nullable(),
+	password: z.string().nullable(),
+	image: z.string().optional(),
+});
+
+export const apiUpdateAuthByAdmin = createSchema.partial().extend({
+	email: z.string().nullable(),
+	password: z.string().nullable(),
+	image: z.string().optional(),
+	id: z.string().min(1),
+});
+
+export const apiFindOneAuth = createSchema
+	.pick({
+		id: true,
+	})
+	.required();
+
+export const apiVerify2FA = createSchema
+	.extend({
+		pin: z.string().min(6),
+		secret: z.string().min(1),
+	})
+	.pick({
+		pin: true,
+		secret: true,
+	})
+	.required();
+
+export const apiVerifyLogin2FA = createSchema
+	.extend({
+		pin: z.string().min(6),
+	})
+	.pick({
+		pin: true,
+		id: true,
+	})
+	.required();

packages/server/src/db/schema/backups.ts

@@ -0,0 +1,131 @@
+import { relations } from "drizzle-orm";
+import {
+	type AnyPgColumn,
+	boolean,
+	pgEnum,
+	pgTable,
+	text,
+} from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { destinations } from "./destination";
+import { mariadb } from "./mariadb";
+import { mongo } from "./mongo";
+import { mysql } from "./mysql";
+import { postgres } from "./postgres";
+
+export const databaseType = pgEnum("databaseType", [
+	"postgres",
+	"mariadb",
+	"mysql",
+	"mongo",
+]);
+
+export const backups = pgTable("backup", {
+	backupId: text("backupId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	schedule: text("schedule").notNull(),
+	enabled: boolean("enabled"),
+	database: text("database").notNull(),
+	prefix: text("prefix").notNull(),
+
+	destinationId: text("destinationId")
+		.notNull()
+		.references(() => destinations.destinationId, { onDelete: "cascade" }),
+
+	databaseType: databaseType("databaseType").notNull(),
+	postgresId: text("postgresId").references(
+		(): AnyPgColumn => postgres.postgresId,
+		{
+			onDelete: "cascade",
+		},
+	),
+	mariadbId: text("mariadbId").references(
+		(): AnyPgColumn => mariadb.mariadbId,
+		{
+			onDelete: "cascade",
+		},
+	),
+	mysqlId: text("mysqlId").references((): AnyPgColumn => mysql.mysqlId, {
+		onDelete: "cascade",
+	}),
+	mongoId: text("mongoId").references((): AnyPgColumn => mongo.mongoId, {
+		onDelete: "cascade",
+	}),
+});
+
+export const backupsRelations = relations(backups, ({ one }) => ({
+	destination: one(destinations, {
+		fields: [backups.destinationId],
+		references: [destinations.destinationId],
+	}),
+	postgres: one(postgres, {
+		fields: [backups.postgresId],
+		references: [postgres.postgresId],
+	}),
+	mariadb: one(mariadb, {
+		fields: [backups.mariadbId],
+		references: [mariadb.mariadbId],
+	}),
+	mysql: one(mysql, {
+		fields: [backups.mysqlId],
+		references: [mysql.mysqlId],
+	}),
+	mongo: one(mongo, {
+		fields: [backups.mongoId],
+		references: [mongo.mongoId],
+	}),
+}));
+
+const createSchema = createInsertSchema(backups, {
+	backupId: z.string(),
+	destinationId: z.string(),
+	enabled: z.boolean().optional(),
+	prefix: z.string().min(1),
+	database: z.string().min(1),
+	schedule: z.string(),
+	databaseType: z.enum(["postgres", "mariadb", "mysql", "mongo"]),
+	postgresId: z.string().optional(),
+	mariadbId: z.string().optional(),
+	mysqlId: z.string().optional(),
+	mongoId: z.string().optional(),
+});
+
+export const apiCreateBackup = createSchema.pick({
+	schedule: true,
+	enabled: true,
+	prefix: true,
+	destinationId: true,
+	database: true,
+	mariadbId: true,
+	mysqlId: true,
+	postgresId: true,
+	mongoId: true,
+	databaseType: true,
+});
+
+export const apiFindOneBackup = createSchema
+	.pick({
+		backupId: true,
+	})
+	.required();
+
+export const apiRemoveBackup = createSchema
+	.pick({
+		backupId: true,
+	})
+	.required();
+
+export const apiUpdateBackup = createSchema
+	.pick({
+		schedule: true,
+		enabled: true,
+		prefix: true,
+		backupId: true,
+		destinationId: true,
+		database: true,
+	})
+	.required();

packages/server/src/db/schema/bitbucket.ts

@@ -0,0 +1,65 @@
+import { relations } from "drizzle-orm";
+import { pgTable, text } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { gitProvider } from "./git-provider";
+
+export const bitbucket = pgTable("bitbucket", {
+	bitbucketId: text("bitbucketId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	bitbucketUsername: text("bitbucketUsername"),
+	appPassword: text("appPassword"),
+	bitbucketWorkspaceName: text("bitbucketWorkspaceName"),
+	gitProviderId: text("gitProviderId")
+		.notNull()
+		.references(() => gitProvider.gitProviderId, { onDelete: "cascade" }),
+});
+
+export const bitbucketProviderRelations = relations(bitbucket, ({ one }) => ({
+	gitProvider: one(gitProvider, {
+		fields: [bitbucket.gitProviderId],
+		references: [gitProvider.gitProviderId],
+	}),
+}));
+
+const createSchema = createInsertSchema(bitbucket);
+
+export const apiCreateBitbucket = createSchema.extend({
+	bitbucketUsername: z.string().optional(),
+	appPassword: z.string().optional(),
+	bitbucketWorkspaceName: z.string().optional(),
+	gitProviderId: z.string().optional(),
+	authId: z.string().min(1),
+	name: z.string().min(1),
+});
+
+export const apiFindOneBitbucket = createSchema
+	.extend({
+		bitbucketId: z.string().min(1),
+	})
+	.pick({ bitbucketId: true });
+
+export const apiBitbucketTestConnection = createSchema
+	.extend({
+		bitbucketId: z.string().min(1),
+		bitbucketUsername: z.string().optional(),
+		workspaceName: z.string().optional(),
+	})
+	.pick({ bitbucketId: true, bitbucketUsername: true, workspaceName: true });
+
+export const apiFindBitbucketBranches = z.object({
+	owner: z.string(),
+	repo: z.string(),
+	bitbucketId: z.string().optional(),
+});
+
+export const apiUpdateBitbucket = createSchema.extend({
+	bitbucketId: z.string().min(1),
+	name: z.string().min(1),
+	bitbucketUsername: z.string().optional(),
+	bitbucketWorkspaceName: z.string().optional(),
+	adminId: z.string().optional(),
+});

packages/server/src/db/schema/certificate.ts

@@ -0,0 +1,43 @@
+import { boolean, pgTable, text } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { generateAppName } from "./utils";
+
+export const certificates = pgTable("certificate", {
+	certificateId: text("certificateId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	name: text("name").notNull(),
+	certificateData: text("certificateData").notNull(),
+	privateKey: text("privateKey").notNull(),
+	certificatePath: text("certificatePath")
+		.notNull()
+		.$defaultFn(() => generateAppName("certificate"))
+		.unique(),
+	autoRenew: boolean("autoRenew"),
+});
+
+export const apiCreateCertificate = createInsertSchema(certificates, {
+	name: z.string().min(1),
+	certificateData: z.string().min(1),
+	privateKey: z.string().min(1),
+	autoRenew: z.boolean().optional(),
+});
+
+export const apiFindCertificate = z.object({
+	certificateId: z.string().min(1),
+});
+
+export const apiUpdateCertificate = z.object({
+	certificateId: z.string().min(1),
+	name: z.string().min(1).optional(),
+	certificateData: z.string().min(1).optional(),
+	privateKey: z.string().min(1).optional(),
+	autoRenew: z.boolean().optional(),
+});
+
+export const apiDeleteCertificate = z.object({
+	certificateId: z.string().min(1),
+});

packages/server/src/db/schema/compose.ts

@@ -0,0 +1,179 @@
+import { relations } from "drizzle-orm";
+import { boolean, integer, pgEnum, pgTable, text } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { bitbucket } from "./bitbucket";
+import { deployments } from "./deployment";
+import { domains } from "./domain";
+import { github } from "./github";
+import { gitlab } from "./gitlab";
+import { mounts } from "./mount";
+import { projects } from "./project";
+import { server } from "./server";
+import { applicationStatus } from "./shared";
+import { sshKeys } from "./ssh-key";
+import { generateAppName } from "./utils";
+
+export const sourceTypeCompose = pgEnum("sourceTypeCompose", [
+	"git",
+	"github",
+	"gitlab",
+	"bitbucket",
+	"raw",
+]);
+
+export const composeType = pgEnum("composeType", ["docker-compose", "stack"]);
+
+export const compose = pgTable("compose", {
+	composeId: text("composeId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	name: text("name").notNull(),
+	appName: text("appName")
+		.notNull()
+		.$defaultFn(() => generateAppName("compose")),
+	description: text("description"),
+	env: text("env"),
+	composeFile: text("composeFile").notNull().default(""),
+	refreshToken: text("refreshToken").$defaultFn(() => nanoid()),
+	sourceType: sourceTypeCompose("sourceType").notNull().default("github"),
+	composeType: composeType("composeType").notNull().default("docker-compose"),
+	// Github
+	repository: text("repository"),
+	owner: text("owner"),
+	branch: text("branch"),
+	autoDeploy: boolean("autoDeploy").$defaultFn(() => true),
+	// Gitlab
+	gitlabProjectId: integer("gitlabProjectId"),
+	gitlabRepository: text("gitlabRepository"),
+	gitlabOwner: text("gitlabOwner"),
+	gitlabBranch: text("gitlabBranch"),
+	gitlabPathNamespace: text("gitlabPathNamespace"),
+	// Bitbucket
+	bitbucketRepository: text("bitbucketRepository"),
+	bitbucketOwner: text("bitbucketOwner"),
+	bitbucketBranch: text("bitbucketBranch"),
+	// Git
+	customGitUrl: text("customGitUrl"),
+	customGitBranch: text("customGitBranch"),
+	customGitSSHKeyId: text("customGitSSHKeyId").references(
+		() => sshKeys.sshKeyId,
+		{
+			onDelete: "set null",
+		},
+	),
+	command: text("command").notNull().default(""),
+	//
+	composePath: text("composePath").notNull().default("./docker-compose.yml"),
+	suffix: text("suffix").notNull().default(""),
+	randomize: boolean("randomize").notNull().default(false),
+	composeStatus: applicationStatus("composeStatus").notNull().default("idle"),
+	projectId: text("projectId")
+		.notNull()
+		.references(() => projects.projectId, { onDelete: "cascade" }),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+
+	githubId: text("githubId").references(() => github.githubId, {
+		onDelete: "set null",
+	}),
+	gitlabId: text("gitlabId").references(() => gitlab.gitlabId, {
+		onDelete: "set null",
+	}),
+	bitbucketId: text("bitbucketId").references(() => bitbucket.bitbucketId, {
+		onDelete: "set null",
+	}),
+	serverId: text("serverId").references(() => server.serverId, {
+		onDelete: "cascade",
+	}),
+});
+
+export const composeRelations = relations(compose, ({ one, many }) => ({
+	project: one(projects, {
+		fields: [compose.projectId],
+		references: [projects.projectId],
+	}),
+	deployments: many(deployments),
+	mounts: many(mounts),
+	customGitSSHKey: one(sshKeys, {
+		fields: [compose.customGitSSHKeyId],
+		references: [sshKeys.sshKeyId],
+	}),
+	domains: many(domains),
+	github: one(github, {
+		fields: [compose.githubId],
+		references: [github.githubId],
+	}),
+	gitlab: one(gitlab, {
+		fields: [compose.gitlabId],
+		references: [gitlab.gitlabId],
+	}),
+	bitbucket: one(bitbucket, {
+		fields: [compose.bitbucketId],
+		references: [bitbucket.bitbucketId],
+	}),
+	server: one(server, {
+		fields: [compose.serverId],
+		references: [server.serverId],
+	}),
+}));
+
+const createSchema = createInsertSchema(compose, {
+	name: z.string().min(1),
+	description: z.string(),
+	env: z.string().optional(),
+	composeFile: z.string().min(1),
+	projectId: z.string(),
+	customGitSSHKeyId: z.string().optional(),
+	command: z.string().optional(),
+	composePath: z.string().min(1),
+	composeType: z.enum(["docker-compose", "stack"]).optional(),
+});
+
+export const apiCreateCompose = createSchema.pick({
+	name: true,
+	description: true,
+	projectId: true,
+	composeType: true,
+	appName: true,
+	serverId: true,
+});
+
+export const apiCreateComposeByTemplate = createSchema
+	.pick({
+		projectId: true,
+	})
+	.extend({
+		id: z.string().min(1),
+		serverId: z.string().optional(),
+	});
+
+export const apiFindCompose = z.object({
+	composeId: z.string().min(1),
+});
+
+export const apiFetchServices = z.object({
+	composeId: z.string().min(1),
+	type: z.enum(["fetch", "cache"]).optional().default("cache"),
+});
+
+export const apiUpdateCompose = createSchema
+	.partial()
+	.extend({
+		composeId: z.string(),
+		composeFile: z.string().optional(),
+		command: z.string().optional(),
+	})
+	.omit({ serverId: true });
+
+export const apiRandomizeCompose = createSchema
+	.pick({
+		composeId: true,
+	})
+	.extend({
+		suffix: z.string().optional(),
+		composeId: z.string().min(1),
+	});

packages/server/src/db/schema/deployment.ts

@@ -0,0 +1,125 @@
+import { relations } from "drizzle-orm";
+import { pgEnum, pgTable, text } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { applications } from "./application";
+import { compose } from "./compose";
+import { server } from "./server";
+
+export const deploymentStatus = pgEnum("deploymentStatus", [
+	"running",
+	"done",
+	"error",
+]);
+
+export const deployments = pgTable("deployment", {
+	deploymentId: text("deploymentId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	title: text("title").notNull(),
+	description: text("description"),
+	status: deploymentStatus("status").default("running"),
+	logPath: text("logPath").notNull(),
+	applicationId: text("applicationId").references(
+		() => applications.applicationId,
+		{ onDelete: "cascade" },
+	),
+	composeId: text("composeId").references(() => compose.composeId, {
+		onDelete: "cascade",
+	}),
+	serverId: text("serverId").references(() => server.serverId, {
+		onDelete: "cascade",
+	}),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+});
+
+export const deploymentsRelations = relations(deployments, ({ one }) => ({
+	application: one(applications, {
+		fields: [deployments.applicationId],
+		references: [applications.applicationId],
+	}),
+	compose: one(compose, {
+		fields: [deployments.composeId],
+		references: [compose.composeId],
+	}),
+	server: one(server, {
+		fields: [deployments.serverId],
+		references: [server.serverId],
+	}),
+}));
+
+const schema = createInsertSchema(deployments, {
+	title: z.string().min(1),
+	status: z.string().default("running"),
+	logPath: z.string().min(1),
+	applicationId: z.string(),
+	composeId: z.string(),
+	description: z.string().optional(),
+});
+
+export const apiCreateDeployment = schema
+	.pick({
+		title: true,
+		status: true,
+		logPath: true,
+		applicationId: true,
+		description: true,
+	})
+	.extend({
+		applicationId: z.string().min(1),
+	});
+
+export const apiCreateDeploymentCompose = schema
+	.pick({
+		title: true,
+		status: true,
+		logPath: true,
+		composeId: true,
+		description: true,
+	})
+	.extend({
+		composeId: z.string().min(1),
+	});
+
+export const apiCreateDeploymentServer = schema
+	.pick({
+		title: true,
+		status: true,
+		logPath: true,
+		serverId: true,
+		description: true,
+	})
+	.extend({
+		serverId: z.string().min(1),
+	});
+
+export const apiFindAllByApplication = schema
+	.pick({
+		applicationId: true,
+	})
+	.extend({
+		applicationId: z.string().min(1),
+	})
+	.required();
+
+export const apiFindAllByCompose = schema
+	.pick({
+		composeId: true,
+	})
+	.extend({
+		composeId: z.string().min(1),
+	})
+	.required();
+
+export const apiFindAllByServer = schema
+	.pick({
+		serverId: true,
+	})
+	.extend({
+		serverId: z.string().min(1),
+	})
+	.required();

packages/server/src/db/schema/destination.ts

@@ -0,0 +1,80 @@
+import { relations } from "drizzle-orm";
+import { pgTable, text } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { admins } from "./admin";
+import { backups } from "./backups";
+
+export const destinations = pgTable("destination", {
+	destinationId: text("destinationId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	name: text("name").notNull(),
+	accessKey: text("accessKey").notNull(),
+	secretAccessKey: text("secretAccessKey").notNull(),
+	bucket: text("bucket").notNull(),
+	region: text("region").notNull(),
+	//   maybe it can be null
+	endpoint: text("endpoint").notNull(),
+	adminId: text("adminId")
+		.notNull()
+		.references(() => admins.adminId, { onDelete: "cascade" }),
+});
+
+export const destinationsRelations = relations(
+	destinations,
+	({ many, one }) => ({
+		backups: many(backups),
+		admin: one(admins, {
+			fields: [destinations.adminId],
+			references: [admins.adminId],
+		}),
+	}),
+);
+
+const createSchema = createInsertSchema(destinations, {
+	destinationId: z.string(),
+	name: z.string().min(1),
+	accessKey: z.string(),
+	bucket: z.string(),
+	endpoint: z.string(),
+	secretAccessKey: z.string(),
+	region: z.string(),
+});
+
+export const apiCreateDestination = createSchema
+	.pick({
+		name: true,
+		accessKey: true,
+		bucket: true,
+		region: true,
+		endpoint: true,
+		secretAccessKey: true,
+	})
+	.required();
+
+export const apiFindOneDestination = createSchema
+	.pick({
+		destinationId: true,
+	})
+	.required();
+
+export const apiRemoveDestination = createSchema
+	.pick({
+		destinationId: true,
+	})
+	.required();
+
+export const apiUpdateDestination = createSchema
+	.pick({
+		name: true,
+		accessKey: true,
+		bucket: true,
+		region: true,
+		endpoint: true,
+		secretAccessKey: true,
+		destinationId: true,
+	})
+	.required();

packages/server/src/db/schema/domain.ts

@@ -0,0 +1,98 @@
+import { relations } from "drizzle-orm";
+import {
+	boolean,
+	integer,
+	pgEnum,
+	pgTable,
+	serial,
+	text,
+} from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { domain } from "../validations/domain";
+import { applications } from "./application";
+import { compose } from "./compose";
+import { certificateType } from "./shared";
+
+export const domainType = pgEnum("domainType", ["compose", "application"]);
+
+export const domains = pgTable("domain", {
+	domainId: text("domainId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	host: text("host").notNull(),
+	https: boolean("https").notNull().default(false),
+	port: integer("port").default(3000),
+	path: text("path").default("/"),
+	serviceName: text("serviceName"),
+	domainType: domainType("domainType").default("application"),
+	uniqueConfigKey: serial("uniqueConfigKey"),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+	composeId: text("composeId").references(() => compose.composeId, {
+		onDelete: "cascade",
+	}),
+	applicationId: text("applicationId").references(
+		() => applications.applicationId,
+		{ onDelete: "cascade" },
+	),
+	certificateType: certificateType("certificateType").notNull().default("none"),
+});
+
+export const domainsRelations = relations(domains, ({ one }) => ({
+	application: one(applications, {
+		fields: [domains.applicationId],
+		references: [applications.applicationId],
+	}),
+	compose: one(compose, {
+		fields: [domains.composeId],
+		references: [compose.composeId],
+	}),
+}));
+
+const createSchema = createInsertSchema(domains, domain._def.schema.shape);
+
+export const apiCreateDomain = createSchema.pick({
+	host: true,
+	path: true,
+	port: true,
+	https: true,
+	applicationId: true,
+	certificateType: true,
+	composeId: true,
+	serviceName: true,
+	domainType: true,
+});
+
+export const apiFindDomain = createSchema
+	.pick({
+		domainId: true,
+	})
+	.required();
+
+export const apiFindDomainByApplication = createSchema.pick({
+	applicationId: true,
+});
+
+export const apiCreateTraefikMeDomain = createSchema.pick({}).extend({
+	appName: z.string().min(1),
+});
+
+export const apiFindDomainByCompose = createSchema.pick({
+	composeId: true,
+});
+
+export const apiUpdateDomain = createSchema
+	.pick({
+		host: true,
+		path: true,
+		port: true,
+		https: true,
+		certificateType: true,
+		serviceName: true,
+		domainType: true,
+	})
+	.merge(createSchema.pick({ domainId: true }).required());

packages/server/src/db/schema/git-provider.ts

@@ -0,0 +1,57 @@
+import { relations } from "drizzle-orm";
+import { pgEnum, pgTable, text } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { admins } from "./admin";
+import { bitbucket } from "./bitbucket";
+import { github } from "./github";
+import { gitlab } from "./gitlab";
+
+export const gitProviderType = pgEnum("gitProviderType", [
+	"github",
+	"gitlab",
+	"bitbucket",
+]);
+
+export const gitProvider = pgTable("git_provider", {
+	gitProviderId: text("gitProviderId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	name: text("name").notNull(),
+	providerType: gitProviderType("providerType").notNull().default("github"),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+	adminId: text("adminId").references(() => admins.adminId, {
+		onDelete: "cascade",
+	}),
+});
+
+export const gitProviderRelations = relations(gitProvider, ({ one, many }) => ({
+	github: one(github, {
+		fields: [gitProvider.gitProviderId],
+		references: [github.gitProviderId],
+	}),
+	gitlab: one(gitlab, {
+		fields: [gitProvider.gitProviderId],
+		references: [gitlab.gitProviderId],
+	}),
+	bitbucket: one(bitbucket, {
+		fields: [gitProvider.gitProviderId],
+		references: [bitbucket.gitProviderId],
+	}),
+	admin: one(admins, {
+		fields: [gitProvider.adminId],
+		references: [admins.adminId],
+	}),
+}));
+
+const createSchema = createInsertSchema(gitProvider);
+
+export const apiRemoveGitProvider = createSchema
+	.extend({
+		gitProviderId: z.string().min(1),
+	})
+	.pick({ gitProviderId: true });

packages/server/src/db/schema/github.ts

@@ -0,0 +1,61 @@
+import { relations } from "drizzle-orm";
+import { integer, pgTable, text } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { gitProvider } from "./git-provider";
+
+export const github = pgTable("github", {
+	githubId: text("githubId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	githubAppName: text("githubAppName"),
+	githubAppId: integer("githubAppId"),
+	githubClientId: text("githubClientId"),
+	githubClientSecret: text("githubClientSecret"),
+	githubInstallationId: text("githubInstallationId"),
+	githubPrivateKey: text("githubPrivateKey"),
+	githubWebhookSecret: text("githubWebhookSecret"),
+	gitProviderId: text("gitProviderId")
+		.notNull()
+		.references(() => gitProvider.gitProviderId, { onDelete: "cascade" }),
+});
+
+export const githubProviderRelations = relations(github, ({ one }) => ({
+	gitProvider: one(gitProvider, {
+		fields: [github.gitProviderId],
+		references: [gitProvider.gitProviderId],
+	}),
+}));
+
+const createSchema = createInsertSchema(github);
+export const apiCreateGithub = createSchema.extend({
+	githubAppName: z.string().optional(),
+	githubAppId: z.number().optional(),
+	githubClientId: z.string().optional(),
+	githubClientSecret: z.string().optional(),
+	githubInstallationId: z.string().optional(),
+	githubPrivateKey: z.string().optional(),
+	githubWebhookSecret: z.string().nullable(),
+	gitProviderId: z.string().optional(),
+	name: z.string().min(1),
+});
+
+export const apiFindGithubBranches = z.object({
+	repo: z.string().min(1),
+	owner: z.string().min(1),
+	githubId: z.string().optional(),
+});
+
+export const apiFindOneGithub = createSchema
+	.extend({
+		githubId: z.string().min(1),
+	})
+	.pick({ githubId: true });
+
+export const apiUpdateGithub = createSchema.extend({
+	githubId: z.string().min(1),
+	name: z.string().min(1),
+	gitProviderId: z.string().min(1),
+});

packages/server/src/db/schema/gitlab.ts

@@ -0,0 +1,70 @@
+import { relations } from "drizzle-orm";
+import { integer, pgTable, text } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { gitProvider } from "./git-provider";
+
+export const gitlab = pgTable("gitlab", {
+	gitlabId: text("gitlabId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	applicationId: text("application_id"),
+	redirectUri: text("redirect_uri"),
+	secret: text("secret"),
+	accessToken: text("access_token"),
+	refreshToken: text("refresh_token"),
+	groupName: text("group_name"),
+	expiresAt: integer("expires_at"),
+	gitProviderId: text("gitProviderId")
+		.notNull()
+		.references(() => gitProvider.gitProviderId, { onDelete: "cascade" }),
+});
+
+export const gitlabProviderRelations = relations(gitlab, ({ one }) => ({
+	gitProvider: one(gitProvider, {
+		fields: [gitlab.gitProviderId],
+		references: [gitProvider.gitProviderId],
+	}),
+}));
+
+const createSchema = createInsertSchema(gitlab);
+
+export const apiCreateGitlab = createSchema.extend({
+	applicationId: z.string().optional(),
+	secret: z.string().optional(),
+	groupName: z.string().optional(),
+	gitProviderId: z.string().optional(),
+	redirectUri: z.string().optional(),
+	authId: z.string().min(1),
+	name: z.string().min(1),
+});
+
+export const apiFindOneGitlab = createSchema
+	.extend({
+		gitlabId: z.string().min(1),
+	})
+	.pick({ gitlabId: true });
+
+export const apiGitlabTestConnection = createSchema
+	.extend({
+		groupName: z.string().optional(),
+	})
+	.pick({ gitlabId: true, groupName: true });
+
+export const apiFindGitlabBranches = z.object({
+	id: z.number().optional(),
+	owner: z.string(),
+	repo: z.string(),
+	gitlabId: z.string().optional(),
+});
+
+export const apiUpdateGitlab = createSchema.extend({
+	applicationId: z.string().optional(),
+	secret: z.string().optional(),
+	groupName: z.string().optional(),
+	redirectUri: z.string().optional(),
+	name: z.string().min(1),
+	gitlabId: z.string().min(1),
+});

packages/server/src/db/schema/index.ts

@@ -0,0 +1,31 @@
+export * from "./application";
+export * from "./postgres";
+export * from "./user";
+export * from "./admin";
+export * from "./auth";
+export * from "./project";
+export * from "./domain";
+export * from "./mariadb";
+export * from "./mongo";
+export * from "./mysql";
+export * from "./backups";
+export * from "./destination";
+export * from "./deployment";
+export * from "./mount";
+export * from "./certificate";
+export * from "./session";
+export * from "./redirects";
+export * from "./security";
+export * from "./port";
+export * from "./redis";
+export * from "./shared";
+export * from "./compose";
+export * from "./registry";
+export * from "./notification";
+export * from "./ssh-key";
+export * from "./git-provider";
+export * from "./bitbucket";
+export * from "./github";
+export * from "./gitlab";
+export * from "./server";
+export * from "./utils";

packages/server/src/db/schema/mariadb.ts

@@ -0,0 +1,148 @@
+import { relations } from "drizzle-orm";
+import { integer, pgTable, text } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { backups } from "./backups";
+import { mounts } from "./mount";
+import { projects } from "./project";
+import { server } from "./server";
+import { applicationStatus } from "./shared";
+import { generateAppName } from "./utils";
+
+export const mariadb = pgTable("mariadb", {
+	mariadbId: text("mariadbId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	name: text("name").notNull(),
+	appName: text("appName")
+		.notNull()
+		.$defaultFn(() => generateAppName("mariadb"))
+		.unique(),
+	description: text("description"),
+	databaseName: text("databaseName").notNull(),
+	databaseUser: text("databaseUser").notNull(),
+	databasePassword: text("databasePassword").notNull(),
+	databaseRootPassword: text("rootPassword").notNull(),
+	dockerImage: text("dockerImage").notNull(),
+	command: text("command"),
+	env: text("env"),
+	// RESOURCES
+	memoryReservation: integer("memoryReservation"),
+	memoryLimit: integer("memoryLimit"),
+	cpuReservation: integer("cpuReservation"),
+	cpuLimit: integer("cpuLimit"),
+	//
+	externalPort: integer("externalPort"),
+	applicationStatus: applicationStatus("applicationStatus")
+		.notNull()
+		.default("idle"),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+	projectId: text("projectId")
+		.notNull()
+		.references(() => projects.projectId, { onDelete: "cascade" }),
+	serverId: text("serverId").references(() => server.serverId, {
+		onDelete: "cascade",
+	}),
+});
+
+export const mariadbRelations = relations(mariadb, ({ one, many }) => ({
+	project: one(projects, {
+		fields: [mariadb.projectId],
+		references: [projects.projectId],
+	}),
+	backups: many(backups),
+	mounts: many(mounts),
+	server: one(server, {
+		fields: [mariadb.serverId],
+		references: [server.serverId],
+	}),
+}));
+
+const createSchema = createInsertSchema(mariadb, {
+	mariadbId: z.string(),
+	name: z.string().min(1),
+	appName: z.string().min(1),
+	createdAt: z.string(),
+	databaseName: z.string().min(1),
+	databaseUser: z.string().min(1),
+	databasePassword: z.string(),
+	databaseRootPassword: z.string().optional(),
+	dockerImage: z.string().default("mariadb:6"),
+	command: z.string().optional(),
+	env: z.string().optional(),
+	memoryReservation: z.number().optional(),
+	memoryLimit: z.number().optional(),
+	cpuReservation: z.number().optional(),
+	cpuLimit: z.number().optional(),
+	projectId: z.string(),
+	applicationStatus: z.enum(["idle", "running", "done", "error"]),
+	externalPort: z.number(),
+	description: z.string().optional(),
+	serverId: z.string().optional(),
+});
+
+export const apiCreateMariaDB = createSchema
+	.pick({
+		name: true,
+		appName: true,
+		dockerImage: true,
+		databaseRootPassword: true,
+		projectId: true,
+		description: true,
+		databaseName: true,
+		databaseUser: true,
+		databasePassword: true,
+		serverId: true,
+	})
+	.required();
+
+export const apiFindOneMariaDB = createSchema
+	.pick({
+		mariadbId: true,
+	})
+	.required();
+
+export const apiChangeMariaDBStatus = createSchema
+	.pick({
+		mariadbId: true,
+		applicationStatus: true,
+	})
+	.required();
+
+export const apiSaveEnvironmentVariablesMariaDB = createSchema
+	.pick({
+		mariadbId: true,
+		env: true,
+	})
+	.required();
+
+export const apiSaveExternalPortMariaDB = createSchema
+	.pick({
+		mariadbId: true,
+		externalPort: true,
+	})
+	.required();
+
+export const apiDeployMariaDB = createSchema
+	.pick({
+		mariadbId: true,
+	})
+	.required();
+
+export const apiResetMariadb = createSchema
+	.pick({
+		mariadbId: true,
+		appName: true,
+	})
+	.required();
+
+export const apiUpdateMariaDB = createSchema
+	.partial()
+	.extend({
+		mariadbId: z.string().min(1),
+	})
+	.omit({ serverId: true });

packages/server/src/db/schema/mongo.ts

@@ -0,0 +1,140 @@
+import { relations } from "drizzle-orm";
+import { integer, pgTable, text } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { backups } from "./backups";
+import { mounts } from "./mount";
+import { projects } from "./project";
+import { server } from "./server";
+import { applicationStatus } from "./shared";
+import { generateAppName } from "./utils";
+
+export const mongo = pgTable("mongo", {
+	mongoId: text("mongoId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	name: text("name").notNull(),
+	appName: text("appName")
+		.notNull()
+		.$defaultFn(() => generateAppName("mongo"))
+		.unique(),
+	description: text("description"),
+	databaseUser: text("databaseUser").notNull(),
+	databasePassword: text("databasePassword").notNull(),
+	dockerImage: text("dockerImage").notNull(),
+	command: text("command"),
+	env: text("env"),
+	memoryReservation: integer("memoryReservation"),
+	memoryLimit: integer("memoryLimit"),
+	cpuReservation: integer("cpuReservation"),
+	cpuLimit: integer("cpuLimit"),
+	externalPort: integer("externalPort"),
+	applicationStatus: applicationStatus("applicationStatus")
+		.notNull()
+		.default("idle"),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+	projectId: text("projectId")
+		.notNull()
+		.references(() => projects.projectId, { onDelete: "cascade" }),
+	serverId: text("serverId").references(() => server.serverId, {
+		onDelete: "cascade",
+	}),
+});
+
+export const mongoRelations = relations(mongo, ({ one, many }) => ({
+	project: one(projects, {
+		fields: [mongo.projectId],
+		references: [projects.projectId],
+	}),
+	backups: many(backups),
+	mounts: many(mounts),
+	server: one(server, {
+		fields: [mongo.serverId],
+		references: [server.serverId],
+	}),
+}));
+
+const createSchema = createInsertSchema(mongo, {
+	appName: z.string().min(1),
+	createdAt: z.string(),
+	mongoId: z.string(),
+	name: z.string().min(1),
+	databasePassword: z.string(),
+	databaseUser: z.string().min(1),
+	dockerImage: z.string().default("mongo:15"),
+	command: z.string().optional(),
+	env: z.string().optional(),
+	memoryReservation: z.number().optional(),
+	memoryLimit: z.number().optional(),
+	cpuReservation: z.number().optional(),
+	cpuLimit: z.number().optional(),
+	projectId: z.string(),
+	applicationStatus: z.enum(["idle", "running", "done", "error"]),
+	externalPort: z.number(),
+	description: z.string().optional(),
+	serverId: z.string().optional(),
+});
+
+export const apiCreateMongo = createSchema
+	.pick({
+		name: true,
+		appName: true,
+		dockerImage: true,
+		projectId: true,
+		description: true,
+		databaseUser: true,
+		databasePassword: true,
+		serverId: true,
+	})
+	.required();
+
+export const apiFindOneMongo = createSchema
+	.pick({
+		mongoId: true,
+	})
+	.required();
+
+export const apiChangeMongoStatus = createSchema
+	.pick({
+		mongoId: true,
+		applicationStatus: true,
+	})
+	.required();
+
+export const apiSaveEnvironmentVariablesMongo = createSchema
+	.pick({
+		mongoId: true,
+		env: true,
+	})
+	.required();
+
+export const apiSaveExternalPortMongo = createSchema
+	.pick({
+		mongoId: true,
+		externalPort: true,
+	})
+	.required();
+
+export const apiDeployMongo = createSchema
+	.pick({
+		mongoId: true,
+	})
+	.required();
+
+export const apiUpdateMongo = createSchema
+	.partial()
+	.extend({
+		mongoId: z.string().min(1),
+	})
+	.omit({ serverId: true });
+
+export const apiResetMongo = createSchema
+	.pick({
+		mongoId: true,
+		appName: true,
+	})
+	.required();

packages/server/src/db/schema/mount.ts

@@ -0,0 +1,160 @@
+import { relations } from "drizzle-orm";
+import { pgEnum, pgTable, text } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { applications } from "./application";
+import { compose } from "./compose";
+import { mariadb } from "./mariadb";
+import { mongo } from "./mongo";
+import { mysql } from "./mysql";
+import { postgres } from "./postgres";
+import { redis } from "./redis";
+
+export const serviceType = pgEnum("serviceType", [
+	"application",
+	"postgres",
+	"mysql",
+	"mariadb",
+	"mongo",
+	"redis",
+	"compose",
+]);
+
+export const mountType = pgEnum("mountType", ["bind", "volume", "file"]);
+
+export const mounts = pgTable("mount", {
+	mountId: text("mountId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	type: mountType("type").notNull(),
+	hostPath: text("hostPath"),
+	volumeName: text("volumeName"),
+	filePath: text("filePath"),
+	content: text("content"),
+	serviceType: serviceType("serviceType").notNull().default("application"),
+	mountPath: text("mountPath").notNull(),
+	applicationId: text("applicationId").references(
+		() => applications.applicationId,
+		{ onDelete: "cascade" },
+	),
+	postgresId: text("postgresId").references(() => postgres.postgresId, {
+		onDelete: "cascade",
+	}),
+	mariadbId: text("mariadbId").references(() => mariadb.mariadbId, {
+		onDelete: "cascade",
+	}),
+	mongoId: text("mongoId").references(() => mongo.mongoId, {
+		onDelete: "cascade",
+	}),
+	mysqlId: text("mysqlId").references(() => mysql.mysqlId, {
+		onDelete: "cascade",
+	}),
+	redisId: text("redisId").references(() => redis.redisId, {
+		onDelete: "cascade",
+	}),
+	composeId: text("composeId").references(() => compose.composeId, {
+		onDelete: "cascade",
+	}),
+});
+
+export const MountssRelations = relations(mounts, ({ one }) => ({
+	application: one(applications, {
+		fields: [mounts.applicationId],
+		references: [applications.applicationId],
+	}),
+	postgres: one(postgres, {
+		fields: [mounts.postgresId],
+		references: [postgres.postgresId],
+	}),
+	mariadb: one(mariadb, {
+		fields: [mounts.mariadbId],
+		references: [mariadb.mariadbId],
+	}),
+	mongo: one(mongo, {
+		fields: [mounts.mongoId],
+		references: [mongo.mongoId],
+	}),
+	mysql: one(mysql, {
+		fields: [mounts.mysqlId],
+		references: [mysql.mysqlId],
+	}),
+	redis: one(redis, {
+		fields: [mounts.redisId],
+		references: [redis.redisId],
+	}),
+	compose: one(compose, {
+		fields: [mounts.composeId],
+		references: [compose.composeId],
+	}),
+}));
+
+const createSchema = createInsertSchema(mounts, {
+	applicationId: z.string(),
+	type: z.enum(["bind", "volume", "file"]),
+	hostPath: z.string().optional(),
+	volumeName: z.string().optional(),
+	content: z.string().optional(),
+	mountPath: z.string().min(1),
+	mountId: z.string().optional(),
+	filePath: z.string().optional(),
+	serviceType: z
+		.enum([
+			"application",
+			"postgres",
+			"mysql",
+			"mariadb",
+			"mongo",
+			"redis",
+			"compose",
+		])
+		.default("application"),
+});
+
+export type ServiceType = NonNullable<
+	z.infer<typeof createSchema>["serviceType"]
+>;
+
+export const apiCreateMount = createSchema
+	.pick({
+		type: true,
+		hostPath: true,
+		volumeName: true,
+		content: true,
+		mountPath: true,
+		serviceType: true,
+		filePath: true,
+	})
+	.extend({
+		serviceId: z.string().min(1),
+	});
+
+export const apiFindOneMount = createSchema
+	.pick({
+		mountId: true,
+	})
+	.required();
+
+export const apiRemoveMount = createSchema
+	.pick({
+		mountId: true,
+	})
+	// .extend({
+	// 	appName: z.string().min(1),
+	// })
+	.required();
+
+export const apiFindMountByApplicationId = createSchema
+	.extend({
+		serviceId: z.string().min(1),
+	})
+	.pick({
+		serviceId: true,
+		serviceType: true,
+	})
+	.required();
+
+export const apiUpdateMount = createSchema.partial().extend({
+	mountId: z.string().min(1),
+});

packages/server/src/db/schema/mysql.ts

@@ -0,0 +1,146 @@
+import { relations } from "drizzle-orm";
+import { integer, pgTable, text } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { backups } from "./backups";
+import { mounts } from "./mount";
+import { projects } from "./project";
+import { server } from "./server";
+import { applicationStatus } from "./shared";
+import { generateAppName } from "./utils";
+
+export const mysql = pgTable("mysql", {
+	mysqlId: text("mysqlId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	name: text("name").notNull(),
+	appName: text("appName")
+		.notNull()
+		.$defaultFn(() => generateAppName("mysql"))
+		.unique(),
+	description: text("description"),
+	databaseName: text("databaseName").notNull(),
+	databaseUser: text("databaseUser").notNull(),
+	databasePassword: text("databasePassword").notNull(),
+	databaseRootPassword: text("rootPassword").notNull(),
+	dockerImage: text("dockerImage").notNull(),
+	command: text("command"),
+	env: text("env"),
+	memoryReservation: integer("memoryReservation"),
+	memoryLimit: integer("memoryLimit"),
+	cpuReservation: integer("cpuReservation"),
+	cpuLimit: integer("cpuLimit"),
+	externalPort: integer("externalPort"),
+	applicationStatus: applicationStatus("applicationStatus")
+		.notNull()
+		.default("idle"),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+	projectId: text("projectId")
+		.notNull()
+		.references(() => projects.projectId, { onDelete: "cascade" }),
+	serverId: text("serverId").references(() => server.serverId, {
+		onDelete: "cascade",
+	}),
+});
+
+export const mysqlRelations = relations(mysql, ({ one, many }) => ({
+	project: one(projects, {
+		fields: [mysql.projectId],
+		references: [projects.projectId],
+	}),
+	backups: many(backups),
+	mounts: many(mounts),
+	server: one(server, {
+		fields: [mysql.serverId],
+		references: [server.serverId],
+	}),
+}));
+
+const createSchema = createInsertSchema(mysql, {
+	mysqlId: z.string(),
+	appName: z.string().min(1),
+	createdAt: z.string(),
+	name: z.string().min(1),
+	databaseName: z.string().min(1),
+	databaseUser: z.string().min(1),
+	databasePassword: z.string(),
+	databaseRootPassword: z.string().optional(),
+	dockerImage: z.string().default("mysql:8"),
+	command: z.string().optional(),
+	env: z.string().optional(),
+	memoryReservation: z.number().optional(),
+	memoryLimit: z.number().optional(),
+	cpuReservation: z.number().optional(),
+	cpuLimit: z.number().optional(),
+	projectId: z.string(),
+	applicationStatus: z.enum(["idle", "running", "done", "error"]),
+	externalPort: z.number(),
+	description: z.string().optional(),
+	serverId: z.string().optional(),
+});
+
+export const apiCreateMySql = createSchema
+	.pick({
+		name: true,
+		appName: true,
+		dockerImage: true,
+		projectId: true,
+		description: true,
+		databaseName: true,
+		databaseUser: true,
+		databasePassword: true,
+		databaseRootPassword: true,
+		serverId: true,
+	})
+	.required();
+
+export const apiFindOneMySql = createSchema
+	.pick({
+		mysqlId: true,
+	})
+	.required();
+
+export const apiChangeMySqlStatus = createSchema
+	.pick({
+		mysqlId: true,
+		applicationStatus: true,
+	})
+	.required();
+
+export const apiSaveEnvironmentVariablesMySql = createSchema
+	.pick({
+		mysqlId: true,
+		env: true,
+	})
+	.required();
+
+export const apiSaveExternalPortMySql = createSchema
+	.pick({
+		mysqlId: true,
+		externalPort: true,
+	})
+	.required();
+
+export const apiResetMysql = createSchema
+	.pick({
+		mysqlId: true,
+		appName: true,
+	})
+	.required();
+
+export const apiDeployMySql = createSchema
+	.pick({
+		mysqlId: true,
+	})
+	.required();
+
+export const apiUpdateMySql = createSchema
+	.partial()
+	.extend({
+		mysqlId: z.string().min(1),
+	})
+	.omit({ serverId: true });

packages/server/src/db/schema/notification.ts

@@ -0,0 +1,240 @@
+import { relations } from "drizzle-orm";
+import { boolean, integer, pgEnum, pgTable, text } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { admins } from "./admin";
+
+export const notificationType = pgEnum("notificationType", [
+	"slack",
+	"telegram",
+	"discord",
+	"email",
+]);
+
+export const notifications = pgTable("notification", {
+	notificationId: text("notificationId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	name: text("name").notNull(),
+	appDeploy: boolean("appDeploy").notNull().default(false),
+	appBuildError: boolean("appBuildError").notNull().default(false),
+	databaseBackup: boolean("databaseBackup").notNull().default(false),
+	dokployRestart: boolean("dokployRestart").notNull().default(false),
+	dockerCleanup: boolean("dockerCleanup").notNull().default(false),
+	notificationType: notificationType("notificationType").notNull(),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+	slackId: text("slackId").references(() => slack.slackId, {
+		onDelete: "cascade",
+	}),
+	telegramId: text("telegramId").references(() => telegram.telegramId, {
+		onDelete: "cascade",
+	}),
+	discordId: text("discordId").references(() => discord.discordId, {
+		onDelete: "cascade",
+	}),
+	emailId: text("emailId").references(() => email.emailId, {
+		onDelete: "cascade",
+	}),
+	adminId: text("adminId").references(() => admins.adminId, {
+		onDelete: "cascade",
+	}),
+});
+
+export const slack = pgTable("slack", {
+	slackId: text("slackId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	webhookUrl: text("webhookUrl").notNull(),
+	channel: text("channel"),
+});
+
+export const telegram = pgTable("telegram", {
+	telegramId: text("telegramId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	botToken: text("botToken").notNull(),
+	chatId: text("chatId").notNull(),
+});
+
+export const discord = pgTable("discord", {
+	discordId: text("discordId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	webhookUrl: text("webhookUrl").notNull(),
+});
+
+export const email = pgTable("email", {
+	emailId: text("emailId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	smtpServer: text("smtpServer").notNull(),
+	smtpPort: integer("smtpPort").notNull(),
+	username: text("username").notNull(),
+	password: text("password").notNull(),
+	fromAddress: text("fromAddress").notNull(),
+	toAddresses: text("toAddress").array().notNull(),
+});
+
+export const notificationsRelations = relations(notifications, ({ one }) => ({
+	slack: one(slack, {
+		fields: [notifications.slackId],
+		references: [slack.slackId],
+	}),
+	telegram: one(telegram, {
+		fields: [notifications.telegramId],
+		references: [telegram.telegramId],
+	}),
+	discord: one(discord, {
+		fields: [notifications.discordId],
+		references: [discord.discordId],
+	}),
+	email: one(email, {
+		fields: [notifications.emailId],
+		references: [email.emailId],
+	}),
+	admin: one(admins, {
+		fields: [notifications.adminId],
+		references: [admins.adminId],
+	}),
+}));
+
+export const notificationsSchema = createInsertSchema(notifications);
+
+export const apiCreateSlack = notificationsSchema
+	.pick({
+		appBuildError: true,
+		databaseBackup: true,
+		dokployRestart: true,
+		name: true,
+		appDeploy: true,
+		dockerCleanup: true,
+	})
+	.extend({
+		webhookUrl: z.string().min(1),
+		channel: z.string(),
+	})
+	.required();
+
+export const apiUpdateSlack = apiCreateSlack.partial().extend({
+	notificationId: z.string().min(1),
+	slackId: z.string(),
+	adminId: z.string().optional(),
+});
+
+export const apiTestSlackConnection = apiCreateSlack.pick({
+	webhookUrl: true,
+	channel: true,
+});
+
+export const apiCreateTelegram = notificationsSchema
+	.pick({
+		appBuildError: true,
+		databaseBackup: true,
+		dokployRestart: true,
+		name: true,
+		appDeploy: true,
+		dockerCleanup: true,
+	})
+	.extend({
+		botToken: z.string().min(1),
+		chatId: z.string().min(1),
+	})
+	.required();
+
+export const apiUpdateTelegram = apiCreateTelegram.partial().extend({
+	notificationId: z.string().min(1),
+	telegramId: z.string().min(1),
+	adminId: z.string().optional(),
+});
+
+export const apiTestTelegramConnection = apiCreateTelegram.pick({
+	botToken: true,
+	chatId: true,
+});
+
+export const apiCreateDiscord = notificationsSchema
+	.pick({
+		appBuildError: true,
+		databaseBackup: true,
+		dokployRestart: true,
+		name: true,
+		appDeploy: true,
+		dockerCleanup: true,
+	})
+	.extend({
+		webhookUrl: z.string().min(1),
+	})
+	.required();
+
+export const apiUpdateDiscord = apiCreateDiscord.partial().extend({
+	notificationId: z.string().min(1),
+	discordId: z.string().min(1),
+	adminId: z.string().optional(),
+});
+
+export const apiTestDiscordConnection = apiCreateDiscord.pick({
+	webhookUrl: true,
+});
+
+export const apiCreateEmail = notificationsSchema
+	.pick({
+		appBuildError: true,
+		databaseBackup: true,
+		dokployRestart: true,
+		name: true,
+		appDeploy: true,
+		dockerCleanup: true,
+	})
+	.extend({
+		smtpServer: z.string().min(1),
+		smtpPort: z.number().min(1),
+		username: z.string().min(1),
+		password: z.string().min(1),
+		fromAddress: z.string().min(1),
+		toAddresses: z.array(z.string()).min(1),
+	})
+	.required();
+
+export const apiUpdateEmail = apiCreateEmail.partial().extend({
+	notificationId: z.string().min(1),
+	emailId: z.string().min(1),
+	adminId: z.string().optional(),
+});
+
+export const apiTestEmailConnection = apiCreateEmail.pick({
+	smtpServer: true,
+	smtpPort: true,
+	username: true,
+	password: true,
+	toAddresses: true,
+	fromAddress: true,
+});
+
+export const apiFindOneNotification = notificationsSchema
+	.pick({
+		notificationId: true,
+	})
+	.required();
+
+export const apiSendTest = notificationsSchema
+	.extend({
+		botToken: z.string(),
+		chatId: z.string(),
+		webhookUrl: z.string(),
+		channel: z.string(),
+		smtpServer: z.string(),
+		smtpPort: z.number(),
+		fromAddress: z.string(),
+		username: z.string(),
+		password: z.string(),
+		toAddresses: z.array(z.string()),
+	})
+	.partial();

packages/server/src/db/schema/port.ts

@@ -0,0 +1,61 @@
+import { relations } from "drizzle-orm";
+import { integer, pgEnum, pgTable, text } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { applications } from "./application";
+
+export const protocolType = pgEnum("protocolType", ["tcp", "udp"]);
+
+export const ports = pgTable("port", {
+	portId: text("portId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	publishedPort: integer("publishedPort").notNull(),
+	targetPort: integer("targetPort").notNull(),
+	protocol: protocolType("protocol").notNull(),
+
+	applicationId: text("applicationId")
+		.notNull()
+		.references(() => applications.applicationId, { onDelete: "cascade" }),
+});
+
+export const portsRelations = relations(ports, ({ one }) => ({
+	application: one(applications, {
+		fields: [ports.applicationId],
+		references: [applications.applicationId],
+	}),
+}));
+
+const createSchema = createInsertSchema(ports, {
+	portId: z.string().min(1),
+	applicationId: z.string().min(1),
+	publishedPort: z.number(),
+	targetPort: z.number(),
+	protocol: z.enum(["tcp", "udp"]).default("tcp"),
+});
+
+export const apiCreatePort = createSchema
+	.pick({
+		publishedPort: true,
+		targetPort: true,
+		protocol: true,
+		applicationId: true,
+	})
+	.required();
+
+export const apiFindOnePort = createSchema
+	.pick({
+		portId: true,
+	})
+	.required();
+
+export const apiUpdatePort = createSchema
+	.pick({
+		portId: true,
+		publishedPort: true,
+		targetPort: true,
+		protocol: true,
+	})
+	.required();

packages/server/src/db/schema/postgres.ts

@@ -0,0 +1,142 @@
+import { relations } from "drizzle-orm";
+import { integer, pgTable, text } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { backups } from "./backups";
+import { mounts } from "./mount";
+import { projects } from "./project";
+import { server } from "./server";
+import { applicationStatus } from "./shared";
+import { generateAppName } from "./utils";
+
+export const postgres = pgTable("postgres", {
+	postgresId: text("postgresId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	name: text("name").notNull(),
+	appName: text("appName")
+		.notNull()
+		.$defaultFn(() => generateAppName("postgres"))
+		.unique(),
+	databaseName: text("databaseName").notNull(),
+	databaseUser: text("databaseUser").notNull(),
+	databasePassword: text("databasePassword").notNull(),
+	description: text("description"),
+	dockerImage: text("dockerImage").notNull(),
+	command: text("command"),
+	env: text("env"),
+	memoryReservation: integer("memoryReservation"),
+	externalPort: integer("externalPort"),
+	memoryLimit: integer("memoryLimit"),
+	cpuReservation: integer("cpuReservation"),
+	cpuLimit: integer("cpuLimit"),
+	applicationStatus: applicationStatus("applicationStatus")
+		.notNull()
+		.default("idle"),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+	projectId: text("projectId")
+		.notNull()
+		.references(() => projects.projectId, { onDelete: "cascade" }),
+	serverId: text("serverId").references(() => server.serverId, {
+		onDelete: "cascade",
+	}),
+});
+
+export const postgresRelations = relations(postgres, ({ one, many }) => ({
+	project: one(projects, {
+		fields: [postgres.projectId],
+		references: [projects.projectId],
+	}),
+	backups: many(backups),
+	mounts: many(mounts),
+	server: one(server, {
+		fields: [postgres.serverId],
+		references: [server.serverId],
+	}),
+}));
+
+const createSchema = createInsertSchema(postgres, {
+	postgresId: z.string(),
+	name: z.string().min(1),
+	databasePassword: z.string(),
+	databaseName: z.string().min(1),
+	databaseUser: z.string().min(1),
+	dockerImage: z.string().default("postgres:15"),
+	command: z.string().optional(),
+	env: z.string().optional(),
+	memoryReservation: z.number().optional(),
+	memoryLimit: z.number().optional(),
+	cpuReservation: z.number().optional(),
+	cpuLimit: z.number().optional(),
+	projectId: z.string(),
+	applicationStatus: z.enum(["idle", "running", "done", "error"]),
+	externalPort: z.number(),
+	createdAt: z.string(),
+	description: z.string().optional(),
+	serverId: z.string().optional(),
+});
+
+export const apiCreatePostgres = createSchema
+	.pick({
+		name: true,
+		appName: true,
+		databaseName: true,
+		databaseUser: true,
+		databasePassword: true,
+		dockerImage: true,
+		projectId: true,
+		description: true,
+		serverId: true,
+	})
+	.required();
+
+export const apiFindOnePostgres = createSchema
+	.pick({
+		postgresId: true,
+	})
+	.required();
+
+export const apiChangePostgresStatus = createSchema
+	.pick({
+		postgresId: true,
+		applicationStatus: true,
+	})
+	.required();
+
+export const apiSaveEnvironmentVariablesPostgres = createSchema
+	.pick({
+		postgresId: true,
+		env: true,
+	})
+	.required();
+
+export const apiSaveExternalPortPostgres = createSchema
+	.pick({
+		postgresId: true,
+		externalPort: true,
+	})
+	.required();
+
+export const apiDeployPostgres = createSchema
+	.pick({
+		postgresId: true,
+	})
+	.required();
+
+export const apiResetPostgres = createSchema
+	.pick({
+		postgresId: true,
+		appName: true,
+	})
+	.required();
+
+export const apiUpdatePostgres = createSchema
+	.partial()
+	.extend({
+		postgresId: z.string().min(1),
+	})
+	.omit({ serverId: true });

packages/server/src/db/schema/project.ts

@@ -0,0 +1,74 @@
+import { relations } from "drizzle-orm";
+
+import { pgTable, text } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { admins } from "./admin";
+import { applications } from "./application";
+import { compose } from "./compose";
+import { mariadb } from "./mariadb";
+import { mongo } from "./mongo";
+import { mysql } from "./mysql";
+import { postgres } from "./postgres";
+import { redis } from "./redis";
+
+export const projects = pgTable("project", {
+	projectId: text("projectId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	name: text("name").notNull(),
+	description: text("description"),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+	adminId: text("adminId")
+		.notNull()
+		.references(() => admins.adminId, { onDelete: "cascade" }),
+});
+
+export const projectRelations = relations(projects, ({ many, one }) => ({
+	mysql: many(mysql),
+	postgres: many(postgres),
+	mariadb: many(mariadb),
+	applications: many(applications),
+	mongo: many(mongo),
+	redis: many(redis),
+	compose: many(compose),
+	admin: one(admins, {
+		fields: [projects.adminId],
+		references: [admins.adminId],
+	}),
+}));
+
+const createSchema = createInsertSchema(projects, {
+	projectId: z.string().min(1),
+	name: z.string().min(1),
+	description: z.string().optional(),
+});
+
+export const apiCreateProject = createSchema.pick({
+	name: true,
+	description: true,
+});
+
+export const apiFindOneProject = createSchema
+	.pick({
+		projectId: true,
+	})
+	.required();
+
+export const apiRemoveProject = createSchema
+	.pick({
+		projectId: true,
+	})
+	.required();
+
+export const apiUpdateProject = createSchema
+	.pick({
+		name: true,
+		description: true,
+		projectId: true,
+	})
+	.required();

packages/server/src/db/schema/redirects.ts

@@ -0,0 +1,60 @@
+import { relations } from "drizzle-orm";
+import { boolean, pgTable, serial, text } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { applications } from "./application";
+
+export const redirects = pgTable("redirect", {
+	redirectId: text("redirectId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	regex: text("regex").notNull(),
+	replacement: text("replacement").notNull(),
+	permanent: boolean("permanent").notNull().default(false),
+	uniqueConfigKey: serial("uniqueConfigKey"),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+	applicationId: text("applicationId")
+		.notNull()
+		.references(() => applications.applicationId, { onDelete: "cascade" }),
+});
+
+export const redirectRelations = relations(redirects, ({ one }) => ({
+	application: one(applications, {
+		fields: [redirects.applicationId],
+		references: [applications.applicationId],
+	}),
+}));
+const createSchema = createInsertSchema(redirects, {
+	redirectId: z.string().min(1),
+	regex: z.string().min(1),
+	replacement: z.string().min(1),
+	permanent: z.boolean().optional(),
+});
+
+export const apiFindOneRedirect = createSchema
+	.pick({
+		redirectId: true,
+	})
+	.required();
+
+export const apiCreateRedirect = createSchema
+	.pick({
+		regex: true,
+		replacement: true,
+		permanent: true,
+		applicationId: true,
+	})
+	.required();
+
+export const apiUpdateRedirect = createSchema
+	.pick({
+		redirectId: true,
+		regex: true,
+		replacement: true,
+		permanent: true,
+	})
+	.required();

packages/server/src/db/schema/redis.ts

@@ -0,0 +1,135 @@
+import { relations } from "drizzle-orm";
+import { integer, pgTable, text } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { mounts } from "./mount";
+import { projects } from "./project";
+import { server } from "./server";
+import { applicationStatus } from "./shared";
+import { generateAppName } from "./utils";
+
+export const redis = pgTable("redis", {
+	redisId: text("redisId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	name: text("name").notNull(),
+	appName: text("appName")
+		.notNull()
+		.$defaultFn(() => generateAppName("redis"))
+		.unique(),
+	description: text("description"),
+	databasePassword: text("password").notNull(),
+	dockerImage: text("dockerImage").notNull(),
+	command: text("command"),
+	env: text("env"),
+	memoryReservation: integer("memoryReservation"),
+	memoryLimit: integer("memoryLimit"),
+	cpuReservation: integer("cpuReservation"),
+	cpuLimit: integer("cpuLimit"),
+	externalPort: integer("externalPort"),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+	applicationStatus: applicationStatus("applicationStatus")
+		.notNull()
+		.default("idle"),
+	projectId: text("projectId")
+		.notNull()
+		.references(() => projects.projectId, { onDelete: "cascade" }),
+	serverId: text("serverId").references(() => server.serverId, {
+		onDelete: "cascade",
+	}),
+});
+
+export const redisRelations = relations(redis, ({ one, many }) => ({
+	project: one(projects, {
+		fields: [redis.projectId],
+		references: [projects.projectId],
+	}),
+	mounts: many(mounts),
+	server: one(server, {
+		fields: [redis.serverId],
+		references: [server.serverId],
+	}),
+}));
+
+const createSchema = createInsertSchema(redis, {
+	redisId: z.string(),
+	appName: z.string().min(1),
+	createdAt: z.string(),
+	name: z.string().min(1),
+	databasePassword: z.string(),
+	dockerImage: z.string().default("redis:8"),
+	command: z.string().optional(),
+	env: z.string().optional(),
+	memoryReservation: z.number().optional(),
+	memoryLimit: z.number().optional(),
+	cpuReservation: z.number().optional(),
+	cpuLimit: z.number().optional(),
+	projectId: z.string(),
+	applicationStatus: z.enum(["idle", "running", "done", "error"]),
+	externalPort: z.number(),
+	description: z.string().optional(),
+	serverId: z.string().optional(),
+});
+
+export const apiCreateRedis = createSchema
+	.pick({
+		name: true,
+		appName: true,
+		databasePassword: true,
+		dockerImage: true,
+		projectId: true,
+		description: true,
+		serverId: true,
+	})
+	.required();
+
+export const apiFindOneRedis = createSchema
+	.pick({
+		redisId: true,
+	})
+	.required();
+
+export const apiChangeRedisStatus = createSchema
+	.pick({
+		redisId: true,
+		applicationStatus: true,
+	})
+	.required();
+
+export const apiSaveEnvironmentVariablesRedis = createSchema
+	.pick({
+		redisId: true,
+		env: true,
+	})
+	.required();
+
+export const apiSaveExternalPortRedis = createSchema
+	.pick({
+		redisId: true,
+		externalPort: true,
+	})
+	.required();
+
+export const apiDeployRedis = createSchema
+	.pick({
+		redisId: true,
+	})
+	.required();
+
+export const apiResetRedis = createSchema
+	.pick({
+		redisId: true,
+		appName: true,
+	})
+	.required();
+
+export const apiUpdateRedis = createSchema
+	.partial()
+	.extend({
+		redisId: z.string().min(1),
+	})
+	.omit({ serverId: true });

packages/server/src/db/schema/registry.ts

@@ -0,0 +1,103 @@
+import { relations, sql } from "drizzle-orm";
+import { boolean, pgEnum, pgTable, text, timestamp } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { admins } from "./admin";
+import { applications } from "./application";
+import { auth } from "./auth";
+/**
+ * This is an example of how to use the multi-project schema feature of Drizzle ORM. Use the same
+ * database instance for multiple projects.
+ *
+ * @see https://orm.drizzle.team/docs/goodies#multi-project-schema
+ */
+export const registryType = pgEnum("RegistryType", ["selfHosted", "cloud"]);
+
+export const registry = pgTable("registry", {
+	registryId: text("registryId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	registryName: text("registryName").notNull(),
+	imagePrefix: text("imagePrefix"),
+	username: text("username").notNull(),
+	password: text("password").notNull(),
+	registryUrl: text("registryUrl").notNull().default(""),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+	registryType: registryType("selfHosted").notNull().default("cloud"),
+	adminId: text("adminId")
+		.notNull()
+		.references(() => admins.adminId, { onDelete: "cascade" }),
+});
+
+export const registryRelations = relations(registry, ({ one, many }) => ({
+	admin: one(admins, {
+		fields: [registry.adminId],
+		references: [admins.adminId],
+	}),
+	applications: many(applications),
+}));
+
+const createSchema = createInsertSchema(registry, {
+	registryName: z.string().min(1),
+	username: z.string().min(1),
+	password: z.string().min(1),
+	registryUrl: z.string(),
+	adminId: z.string().min(1),
+	registryId: z.string().min(1),
+	registryType: z.enum(["selfHosted", "cloud"]),
+	imagePrefix: z.string().nullable().optional(),
+});
+
+export const apiCreateRegistry = createSchema
+	.pick({})
+	.extend({
+		registryName: z.string().min(1),
+		username: z.string().min(1),
+		password: z.string().min(1),
+		registryUrl: z.string(),
+		registryType: z.enum(["selfHosted", "cloud"]),
+		imagePrefix: z.string().nullable().optional(),
+	})
+	.required()
+	.extend({
+		serverId: z.string().optional(),
+	});
+
+export const apiTestRegistry = createSchema.pick({}).extend({
+	registryName: z.string().min(1),
+	username: z.string().min(1),
+	password: z.string().min(1),
+	registryUrl: z.string(),
+	registryType: z.enum(["selfHosted", "cloud"]),
+	imagePrefix: z.string().nullable().optional(),
+	serverId: z.string().optional(),
+});
+
+export const apiRemoveRegistry = createSchema
+	.pick({
+		registryId: true,
+	})
+	.required();
+
+export const apiFindOneRegistry = createSchema
+	.pick({
+		registryId: true,
+	})
+	.required();
+
+export const apiUpdateRegistry = createSchema.partial().extend({
+	registryId: z.string().min(1),
+	serverId: z.string().optional(),
+});
+
+export const apiEnableSelfHostedRegistry = createSchema
+	.pick({
+		registryUrl: true,
+		username: true,
+		password: true,
+	})
+	.required();

packages/server/src/db/schema/security.ts

@@ -0,0 +1,61 @@
+import { relations } from "drizzle-orm";
+import { pgTable, text, unique } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { applications } from "./application";
+
+export const security = pgTable(
+	"security",
+	{
+		securityId: text("securityId")
+			.notNull()
+			.primaryKey()
+			.$defaultFn(() => nanoid()),
+		username: text("username").notNull(),
+		password: text("password").notNull(),
+		createdAt: text("createdAt")
+			.notNull()
+			.$defaultFn(() => new Date().toISOString()),
+		applicationId: text("applicationId")
+			.notNull()
+			.references(() => applications.applicationId, { onDelete: "cascade" }),
+	},
+	(t) => ({
+		unq: unique().on(t.username, t.applicationId),
+	}),
+);
+
+export const securityRelations = relations(security, ({ one }) => ({
+	application: one(applications, {
+		fields: [security.applicationId],
+		references: [applications.applicationId],
+	}),
+}));
+const createSchema = createInsertSchema(security, {
+	securityId: z.string().min(1),
+	username: z.string().min(1),
+	password: z.string().min(1),
+});
+
+export const apiFindOneSecurity = createSchema
+	.pick({
+		securityId: true,
+	})
+	.required();
+
+export const apiCreateSecurity = createSchema
+	.pick({
+		applicationId: true,
+		username: true,
+		password: true,
+	})
+	.required();
+
+export const apiUpdateSecurity = createSchema
+	.pick({
+		securityId: true,
+		username: true,
+		password: true,
+	})
+	.required();

packages/server/src/db/schema/server.ts

@@ -0,0 +1,102 @@
+import { relations } from "drizzle-orm";
+import { boolean, integer, pgTable, text } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+
+import { admins } from "./admin";
+import { applications } from "./application";
+import { compose } from "./compose";
+import { deployments } from "./deployment";
+import { mariadb } from "./mariadb";
+import { mongo } from "./mongo";
+import { mysql } from "./mysql";
+import { postgres } from "./postgres";
+import { redis } from "./redis";
+import { sshKeys } from "./ssh-key";
+import { generateAppName } from "./utils";
+
+export const server = pgTable("server", {
+	serverId: text("serverId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	name: text("name").notNull(),
+	description: text("description"),
+	ipAddress: text("ipAddress").notNull(),
+	port: integer("port").notNull(),
+	username: text("username").notNull().default("root"),
+	appName: text("appName")
+		.notNull()
+		.$defaultFn(() => generateAppName("server")),
+	enableDockerCleanup: boolean("enableDockerCleanup").notNull().default(false),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+	adminId: text("adminId")
+		.notNull()
+		.references(() => admins.adminId, { onDelete: "cascade" }),
+	sshKeyId: text("sshKeyId").references(() => sshKeys.sshKeyId, {
+		onDelete: "set null",
+	}),
+});
+
+export const serverRelations = relations(server, ({ one, many }) => ({
+	admin: one(admins, {
+		fields: [server.adminId],
+		references: [admins.adminId],
+	}),
+	deployments: many(deployments),
+	sshKey: one(sshKeys, {
+		fields: [server.sshKeyId],
+		references: [sshKeys.sshKeyId],
+	}),
+	applications: many(applications),
+	compose: many(compose),
+	redis: many(redis),
+	mariadb: many(mariadb),
+	mongo: many(mongo),
+	mysql: many(mysql),
+	postgres: many(postgres),
+}));
+
+const createSchema = createInsertSchema(server, {
+	serverId: z.string().min(1),
+	name: z.string().min(1),
+	description: z.string().optional(),
+});
+
+export const apiCreateServer = createSchema
+	.pick({
+		name: true,
+		description: true,
+		ipAddress: true,
+		port: true,
+		username: true,
+		sshKeyId: true,
+	})
+	.required();
+
+export const apiFindOneServer = createSchema
+	.pick({
+		serverId: true,
+	})
+	.required();
+
+export const apiRemoveServer = createSchema
+	.pick({
+		serverId: true,
+	})
+	.required();
+
+export const apiUpdateServer = createSchema
+	.pick({
+		name: true,
+		description: true,
+		serverId: true,
+		ipAddress: true,
+		port: true,
+		username: true,
+		sshKeyId: true,
+	})
+	.required();

packages/server/src/db/schema/session.ts

@@ -0,0 +1,13 @@
+import { pgTable, text, timestamp } from "drizzle-orm/pg-core";
+import { auth } from "./auth";
+
+export const sessionTable = pgTable("session", {
+	id: text("id").primaryKey(),
+	userId: text("user_id")
+		.notNull()
+		.references(() => auth.id, { onDelete: "cascade" }),
+	expiresAt: timestamp("expires_at", {
+		withTimezone: true,
+		mode: "date",
+	}).notNull(),
+});

packages/server/src/db/schema/shared.ts

@@ -0,0 +1,13 @@
+import { pgEnum } from "drizzle-orm/pg-core";
+
+export const applicationStatus = pgEnum("applicationStatus", [
+	"idle",
+	"running",
+	"done",
+	"error",
+]);
+
+export const certificateType = pgEnum("certificateType", [
+	"letsencrypt",
+	"none",
+]);

packages/server/src/db/schema/source.ts

@@ -0,0 +1,27 @@
+import { pgTable, text } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+
+export const source = pgTable("project", {
+	projectId: text("projectId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	name: text("name").notNull(),
+	description: text("description"),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+});
+
+const createSchema = createInsertSchema(source, {
+	name: z.string().min(1),
+	description: z.string(),
+	projectId: z.string(),
+});
+
+export const apiCreate = createSchema.pick({
+	name: true,
+	description: true,
+});

packages/server/src/db/schema/ssh-key.ts

@@ -0,0 +1,82 @@
+import { relations } from "drizzle-orm";
+import { pgTable, text } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { sshKeyCreate, sshKeyType } from "../validations";
+import { admins } from "./admin";
+import { applications } from "./application";
+import { compose } from "./compose";
+import { server } from "./server";
+
+export const sshKeys = pgTable("ssh-key", {
+	sshKeyId: text("sshKeyId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	privateKey: text("privateKey").notNull().default(""),
+	publicKey: text("publicKey").notNull(),
+	name: text("name").notNull(),
+	description: text("description"),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+	lastUsedAt: text("lastUsedAt"),
+	adminId: text("adminId").references(() => admins.adminId, {
+		onDelete: "cascade",
+	}),
+});
+
+export const sshKeysRelations = relations(sshKeys, ({ many, one }) => ({
+	applications: many(applications),
+	compose: many(compose),
+	servers: many(server),
+	admin: one(admins, {
+		fields: [sshKeys.adminId],
+		references: [admins.adminId],
+	}),
+}));
+
+const createSchema = createInsertSchema(
+	sshKeys,
+	/* Private key is not stored in the DB */
+	sshKeyCreate.omit({ privateKey: true }).shape,
+);
+
+export const apiCreateSshKey = createSchema
+	.pick({
+		name: true,
+		description: true,
+		privateKey: true,
+		publicKey: true,
+		adminId: true,
+	})
+	.merge(sshKeyCreate.pick({ privateKey: true }));
+
+export const apiFindOneSshKey = createSchema
+	.pick({
+		sshKeyId: true,
+	})
+	.required();
+
+export const apiGenerateSSHKey = sshKeyType;
+
+export const apiRemoveSshKey = createSchema
+	.pick({
+		sshKeyId: true,
+	})
+	.required();
+
+export const apiUpdateSshKey = createSchema
+	.pick({
+		name: true,
+		description: true,
+		lastUsedAt: true,
+	})
+	.partial()
+	.merge(
+		createSchema
+			.pick({
+				sshKeyId: true,
+			})
+			.required(),
+	);

packages/server/src/db/schema/user.ts

@@ -0,0 +1,129 @@
+import { relations, sql } from "drizzle-orm";
+import { boolean, pgTable, text, timestamp } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { admins } from "./admin";
+import { auth } from "./auth";
+/**
+ * This is an example of how to use the multi-project schema feature of Drizzle ORM. Use the same
+ * database instance for multiple projects.
+ *
+ * @see https://orm.drizzle.team/docs/goodies#multi-project-schema
+ */
+
+export const users = pgTable("user", {
+	userId: text("userId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+
+	token: text("token").notNull(),
+	isRegistered: boolean("isRegistered").notNull().default(false),
+	expirationDate: timestamp("expirationDate", {
+		precision: 3,
+		mode: "string",
+	}).notNull(),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+	canCreateProjects: boolean("canCreateProjects").notNull().default(false),
+	canAccessToSSHKeys: boolean("canAccessToSSHKeys").notNull().default(false),
+	canCreateServices: boolean("canCreateServices").notNull().default(false),
+	canDeleteProjects: boolean("canDeleteProjects").notNull().default(false),
+	canDeleteServices: boolean("canDeleteServices").notNull().default(false),
+	canAccessToDocker: boolean("canAccessToDocker").notNull().default(false),
+	canAccessToAPI: boolean("canAccessToAPI").notNull().default(false),
+	canAccessToGitProviders: boolean("canAccessToGitProviders")
+		.notNull()
+		.default(false),
+	canAccessToTraefikFiles: boolean("canAccessToTraefikFiles")
+		.notNull()
+		.default(false),
+	accesedProjects: text("accesedProjects")
+		.array()
+		.notNull()
+		.default(sql`ARRAY[]::text[]`),
+	accesedServices: text("accesedServices")
+		.array()
+		.notNull()
+		.default(sql`ARRAY[]::text[]`),
+	adminId: text("adminId")
+		.notNull()
+		.references(() => admins.adminId, { onDelete: "cascade" }),
+	authId: text("authId")
+		.notNull()
+		.references(() => auth.id, { onDelete: "cascade" }),
+});
+
+export const usersRelations = relations(users, ({ one }) => ({
+	auth: one(auth, {
+		fields: [users.authId],
+		references: [auth.id],
+	}),
+	admin: one(admins, {
+		fields: [users.adminId],
+		references: [admins.adminId],
+	}),
+}));
+
+const createSchema = createInsertSchema(users, {
+	userId: z.string().min(1),
+	authId: z.string().min(1),
+	token: z.string().min(1),
+	isRegistered: z.boolean().optional(),
+	adminId: z.string(),
+	accesedProjects: z.array(z.string()).optional(),
+	accesedServices: z.array(z.string()).optional(),
+	canCreateProjects: z.boolean().optional(),
+	canCreateServices: z.boolean().optional(),
+	canDeleteProjects: z.boolean().optional(),
+	canDeleteServices: z.boolean().optional(),
+	canAccessToDocker: z.boolean().optional(),
+	canAccessToTraefikFiles: z.boolean().optional(),
+});
+
+export const apiCreateUserInvitation = createSchema.pick({}).extend({
+	email: z.string().email(),
+});
+
+export const apiRemoveUser = createSchema
+	.pick({
+		authId: true,
+	})
+	.required();
+
+export const apiFindOneToken = createSchema
+	.pick({
+		token: true,
+	})
+	.required();
+
+export const apiAssignPermissions = createSchema
+	.pick({
+		userId: true,
+		canCreateProjects: true,
+		canCreateServices: true,
+		canDeleteProjects: true,
+		canDeleteServices: true,
+		accesedProjects: true,
+		accesedServices: true,
+		canAccessToTraefikFiles: true,
+		canAccessToDocker: true,
+		canAccessToAPI: true,
+		canAccessToSSHKeys: true,
+		canAccessToGitProviders: true,
+	})
+	.required();
+
+export const apiFindOneUser = createSchema
+	.pick({
+		userId: true,
+	})
+	.required();
+
+export const apiFindOneUserByAuth = createSchema
+	.pick({
+		authId: true,
+	})
+	.required();

packages/server/src/db/schema/utils.ts

@@ -0,0 +1,15 @@
+import { faker } from "@faker-js/faker";
+import { customAlphabet } from "nanoid";
+
+const alphabet = "abcdefghijklmnopqrstuvwxyz123456789";
+
+const customNanoid = customAlphabet(alphabet, 6);
+
+export const generateAppName = (type: string) => {
+	const verb = faker.hacker.verb().replace(/ /g, "-");
+	const adjective = faker.hacker.adjective().replace(/ /g, "-");
+	const noun = faker.hacker.noun().replace(/ /g, "-");
+	const randomFakerElement = `${verb}-${adjective}-${noun}`;
+	const nanoidPart = customNanoid();
+	return `${type}-${randomFakerElement}-${nanoidPart}`;
+};

packages/server/src/db/seed.ts

@@ -0,0 +1,35 @@
+// import bc from "bcrypt";
+// import { drizzle } from "drizzle-orm/postgres-js";
+// import postgres from "postgres";
+// import { users } from "./schema";
+
+// const connectionString = process.env.DATABASE_URL || "";
+
+// const pg = postgres(connectionString, { max: 1 });
+// const db = drizzle(pg);
+
+// function password(txt: string) {
+// 	return bc.hashSync(txt, 10);
+// }
+
+// async function seed() {
+// 	console.log("> Seed:", process.env.DATABASE_PATH, "\n");
+
+// 	// const authenticationR = await db
+// 	// 	.insert(users)
+// 	// 	.values([
+// 	// 		{
+// 	// 			email: "user1@hotmail.com",
+// 	// 			password: password("12345671"),
+// 	// 		},
+// 	// 	])
+// 	// 	.onConflictDoNothing()
+// 	// 	.returning();
+
+// 	// console.log("\nSemillas Update:", authenticationR.length);
+// }
+
+// seed().catch((e) => {
+// 	console.error(e);
+// 	process.exit(1);
+// });

packages/server/src/db/validations/domain.ts

@@ -0,0 +1,46 @@
+import { z } from "zod";
+
+export const domain = z
+	.object({
+		host: z.string().min(1, { message: "Add a hostname" }),
+		path: z.string().min(1).optional(),
+		port: z
+			.number()
+			.min(1, { message: "Port must be at least 1" })
+			.max(65535, { message: "Port must be 65535 or below" })
+			.optional(),
+		https: z.boolean().optional(),
+		certificateType: z.enum(["letsencrypt", "none"]).optional(),
+	})
+	.superRefine((input, ctx) => {
+		if (input.https && !input.certificateType) {
+			ctx.addIssue({
+				code: z.ZodIssueCode.custom,
+				path: ["certificateType"],
+				message: "Required",
+			});
+		}
+	});
+
+export const domainCompose = z
+	.object({
+		host: z.string().min(1, { message: "Host is required" }),
+		path: z.string().min(1).optional(),
+		port: z
+			.number()
+			.min(1, { message: "Port must be at least 1" })
+			.max(65535, { message: "Port must be 65535 or below" })
+			.optional(),
+		https: z.boolean().optional(),
+		certificateType: z.enum(["letsencrypt", "none"]).optional(),
+		serviceName: z.string().min(1, { message: "Service name is required" }),
+	})
+	.superRefine((input, ctx) => {
+		if (input.https && !input.certificateType) {
+			ctx.addIssue({
+				code: z.ZodIssueCode.custom,
+				path: ["certificateType"],
+				message: "Required",
+			});
+		}
+	});

packages/server/src/db/validations/index.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+
+export const sshKeyCreate = z.object({
+	name: z.string().min(1),
+	description: z.string().optional(),
+	publicKey: z.string().refine(
+		(key) => {
+			const rsaPubPattern = /^ssh-rsa\s+([A-Za-z0-9+/=]+)\s*(.*)?\s*$/;
+			const ed25519PubPattern = /^ssh-ed25519\s+([A-Za-z0-9+/=]+)\s*(.*)?\s*$/;
+			return rsaPubPattern.test(key) || ed25519PubPattern.test(key);
+		},
+		{
+			message: "Invalid public key format",
+		},
+	),
+	privateKey: z.string().refine(
+		(key) => {
+			const rsaPrivPattern =
+				/^-----BEGIN RSA PRIVATE KEY-----\n([A-Za-z0-9+/=\n]+)-----END RSA PRIVATE KEY-----\s*$/;
+			const ed25519PrivPattern =
+				/^-----BEGIN OPENSSH PRIVATE KEY-----\n([A-Za-z0-9+/=\n]+)-----END OPENSSH PRIVATE KEY-----\s*$/;
+			return rsaPrivPattern.test(key) || ed25519PrivPattern.test(key);
+		},
+		{
+			message: "Invalid private key format",
+		},
+	),
+});
+
+export const sshKeyUpdate = sshKeyCreate.pick({
+	name: true,
+	description: true,
+});
+
+export const sshKeyType = z.object({
+	type: z.enum(["rsa", "ed25519"]).optional(),
+});

packages/server/src/emails/.gitignore

@@ -0,0 +1,2 @@
+/node_modules
+/dist

packages/server/src/emails/emails/build-failed.tsx

@@ -0,0 +1,113 @@
+import {
+	Body,
+	Button,
+	Container,
+	Head,
+	Heading,
+	Html,
+	Img,
+	Link,
+	Preview,
+	Section,
+	Tailwind,
+	Text,
+} from "@react-email/components";
+import * as React from "react";
+
+export type TemplateProps = {
+	projectName: string;
+	applicationName: string;
+	applicationType: string;
+	errorMessage: string;
+	buildLink: string;
+	date: string;
+};
+
+export const BuildFailedEmail = ({
+	projectName = "dokploy",
+	applicationName = "frontend",
+	applicationType = "application",
+	errorMessage = "Error array.length is not a function",
+	buildLink = "https://dokploy.com/projects/dokploy-test/applications/dokploy-test",
+	date = "2023-05-01T00:00:00.000Z",
+}: TemplateProps) => {
+	const previewText = `Build failed for ${applicationName}`;
+	return (
+		<Html>
+			<Head />
+			<Preview>{previewText}</Preview>
+			<Tailwind
+				config={{
+					theme: {
+						extend: {
+							colors: {
+								brand: "#007291",
+							},
+						},
+					},
+				}}
+			>
+				<Body className="bg-white my-auto mx-auto font-sans px-2">
+					<Container className="border border-solid border-[#eaeaea] rounded-lg my-[40px] mx-auto p-[20px] max-w-[465px]">
+						<Section className="mt-[32px]">
+							<Img
+								src={
+									"https://raw.githubusercontent.com/Dokploy/dokploy/canary/logo.png"
+								}
+								width="100"
+								height="50"
+								alt="Dokploy"
+								className="my-0 mx-auto"
+							/>
+						</Section>
+						<Heading className="text-black text-[24px] font-normal text-center p-0 my-[30px] mx-0">
+							Build failed for <strong>{applicationName}</strong>
+						</Heading>
+						<Text className="text-black text-[14px] leading-[24px]">
+							Hello,
+						</Text>
+						<Text className="text-black text-[14px] leading-[24px]">
+							Your build for <strong>{applicationName}</strong> failed. Please
+							check the error message below.
+						</Text>
+						<Section className="flex text-black text-[14px]  leading-[24px] bg-[#F4F4F5] rounded-lg p-2">
+							<Text className="!leading-3 font-bold">Details: </Text>
+							<Text className="!leading-3">
+								Project Name: <strong>{projectName}</strong>
+							</Text>
+							<Text className="!leading-3">
+								Application Name: <strong>{applicationName}</strong>
+							</Text>
+							<Text className="!leading-3">
+								Application Type: <strong>{applicationType}</strong>
+							</Text>
+							<Text className="!leading-3">
+								Date: <strong>{date}</strong>
+							</Text>
+						</Section>
+						<Section className="flex text-black text-[14px]  mt-4 leading-[24px] bg-[#F4F4F5] rounded-lg p-2">
+							<Text className="!leading-3 font-bold">Reason: </Text>
+							<Text className="text-[12px] leading-[24px]">{errorMessage}</Text>
+						</Section>
+						<Section className="text-center mt-[32px] mb-[32px]">
+							<Button
+								href={buildLink}
+								className="bg-[#000000] rounded text-white text-[12px] font-semibold no-underline text-center px-5 py-3"
+							>
+								View build
+							</Button>
+						</Section>
+						<Text className="text-black text-[14px] leading-[24px]">
+							or copy and paste this URL into your browser:{" "}
+							<Link href={buildLink} className="text-blue-600 no-underline">
+								{buildLink}
+							</Link>
+						</Text>
+					</Container>
+				</Body>
+			</Tailwind>
+		</Html>
+	);
+};
+
+export default BuildFailedEmail;

packages/server/src/emails/emails/build-success.tsx

@@ -0,0 +1,106 @@
+import {
+	Body,
+	Button,
+	Container,
+	Head,
+	Heading,
+	Html,
+	Img,
+	Link,
+	Preview,
+	Section,
+	Tailwind,
+	Text,
+} from "@react-email/components";
+import * as React from "react";
+
+export type TemplateProps = {
+	projectName: string;
+	applicationName: string;
+	applicationType: string;
+	buildLink: string;
+	date: string;
+};
+
+export const BuildSuccessEmail = ({
+	projectName = "dokploy",
+	applicationName = "frontend",
+	applicationType = "application",
+	buildLink = "https://dokploy.com/projects/dokploy-test/applications/dokploy-test",
+	date = "2023-05-01T00:00:00.000Z",
+}: TemplateProps) => {
+	const previewText = `Build success for ${applicationName}`;
+	return (
+		<Html>
+			<Head />
+			<Preview>{previewText}</Preview>
+			<Tailwind
+				config={{
+					theme: {
+						extend: {
+							colors: {
+								brand: "#007291",
+							},
+						},
+					},
+				}}
+			>
+				<Body className="bg-white my-auto mx-auto font-sans px-2">
+					<Container className="border border-solid border-[#eaeaea] rounded-lg my-[40px] mx-auto p-[20px] max-w-[465px]">
+						<Section className="mt-[32px]">
+							<Img
+								src={
+									"https://raw.githubusercontent.com/Dokploy/dokploy/canary/logo.png"
+								}
+								width="100"
+								height="50"
+								alt="Dokploy"
+								className="my-0 mx-auto"
+							/>
+						</Section>
+						<Heading className="text-black text-[24px] font-normal text-center p-0 my-[30px] mx-0">
+							Build success for <strong>{applicationName}</strong>
+						</Heading>
+						<Text className="text-black text-[14px] leading-[24px]">
+							Hello,
+						</Text>
+						<Text className="text-black text-[14px] leading-[24px]">
+							Your build for <strong>{applicationName}</strong> was successful
+						</Text>
+						<Section className="flex text-black text-[14px]  leading-[24px] bg-[#F4F4F5] rounded-lg p-2">
+							<Text className="!leading-3 font-bold">Details: </Text>
+							<Text className="!leading-3">
+								Project Name: <strong>{projectName}</strong>
+							</Text>
+							<Text className="!leading-3">
+								Application Name: <strong>{applicationName}</strong>
+							</Text>
+							<Text className="!leading-3">
+								Application Type: <strong>{applicationType}</strong>
+							</Text>
+							<Text className="!leading-3">
+								Date: <strong>{date}</strong>
+							</Text>
+						</Section>
+						<Section className="text-center mt-[32px] mb-[32px]">
+							<Button
+								href={buildLink}
+								className="bg-[#000000] rounded text-white text-[12px] font-semibold no-underline text-center px-5 py-3"
+							>
+								View build
+							</Button>
+						</Section>
+						<Text className="text-black text-[14px] leading-[24px]">
+							or copy and paste this URL into your browser:{" "}
+							<Link href={buildLink} className="text-blue-600 no-underline">
+								{buildLink}
+							</Link>
+						</Text>
+					</Container>
+				</Body>
+			</Tailwind>
+		</Html>
+	);
+};
+
+export default BuildSuccessEmail;

packages/server/src/emails/emails/database-backup.tsx

@@ -0,0 +1,105 @@
+import {
+	Body,
+	Container,
+	Head,
+	Heading,
+	Html,
+	Img,
+	Preview,
+	Section,
+	Tailwind,
+	Text,
+} from "@react-email/components";
+import * as React from "react";
+
+export type TemplateProps = {
+	projectName: string;
+	applicationName: string;
+	databaseType: "postgres" | "mysql" | "mongodb" | "mariadb";
+	type: "error" | "success";
+	errorMessage?: string;
+	date: string;
+};
+
+export const DatabaseBackupEmail = ({
+	projectName = "dokploy",
+	applicationName = "frontend",
+	databaseType = "postgres",
+	type = "success",
+	errorMessage,
+	date = "2023-05-01T00:00:00.000Z",
+}: TemplateProps) => {
+	const previewText = `Database backup for ${applicationName} was ${type === "success" ? "successful ✅" : "failed ❌"}`;
+	return (
+		<Html>
+			<Preview>{previewText}</Preview>
+			<Tailwind
+				config={{
+					theme: {
+						extend: {
+							colors: {
+								brand: "#007291",
+							},
+						},
+					},
+				}}
+			>
+				<Head />
+
+				<Body className="bg-white my-auto mx-auto font-sans px-2">
+					<Container className="border border-solid border-[#eaeaea] rounded-lg my-[40px] mx-auto p-[20px] max-w-[465px]">
+						<Section className="mt-[32px]">
+							<Img
+								src={
+									"https://raw.githubusercontent.com/Dokploy/dokploy/canary/logo.png"
+								}
+								width="100"
+								height="50"
+								alt="Dokploy"
+								className="my-0 mx-auto"
+							/>
+						</Section>
+						<Heading className="text-black text-[24px] font-normal text-center p-0 my-[30px] mx-0">
+							Database backup for <strong>{applicationName}</strong>
+						</Heading>
+						<Text className="text-black text-[14px] leading-[24px]">
+							Hello,
+						</Text>
+						<Text className="text-black text-[14px] leading-[24px]">
+							Your database backup for <strong>{applicationName}</strong> was{" "}
+							{type === "success"
+								? "successful ✅"
+								: "failed  Please check the error message below. ❌"}
+							.
+						</Text>
+						<Section className="flex text-black text-[14px]  leading-[24px] bg-[#F4F4F5] rounded-lg p-2">
+							<Text className="!leading-3 font-bold">Details: </Text>
+							<Text className="!leading-3">
+								Project Name: <strong>{projectName}</strong>
+							</Text>
+							<Text className="!leading-3">
+								Application Name: <strong>{applicationName}</strong>
+							</Text>
+							<Text className="!leading-3">
+								Database Type: <strong>{databaseType}</strong>
+							</Text>
+							<Text className="!leading-3">
+								Date: <strong>{date}</strong>
+							</Text>
+						</Section>
+						{type === "error" && errorMessage ? (
+							<Section className="flex text-black text-[14px]  mt-4 leading-[24px] bg-[#F4F4F5] rounded-lg p-2">
+								<Text className="!leading-3 font-bold">Reason: </Text>
+								<Text className="text-[12px] leading-[24px]">
+									{errorMessage || "Error message not provided"}
+								</Text>
+							</Section>
+						) : null}
+					</Container>
+				</Body>
+			</Tailwind>
+		</Html>
+	);
+};
+
+export default DatabaseBackupEmail;

packages/server/src/emails/emails/docker-cleanup.tsx

@@ -0,0 +1,81 @@
+import {
+	Body,
+	Button,
+	Container,
+	Head,
+	Heading,
+	Html,
+	Img,
+	Preview,
+	Section,
+	Tailwind,
+	Text,
+} from "@react-email/components";
+import * as React from "react";
+
+export type TemplateProps = {
+	message: string;
+	date: string;
+};
+
+export const DockerCleanupEmail = ({
+	message = "Docker cleanup for dokploy",
+	date = "2023-05-01T00:00:00.000Z",
+}: TemplateProps) => {
+	const previewText = "Docker cleanup for dokploy";
+	return (
+		<Html>
+			<Preview>{previewText}</Preview>
+			<Tailwind
+				config={{
+					theme: {
+						extend: {
+							colors: {
+								brand: "#007291",
+							},
+						},
+					},
+				}}
+			>
+				<Head />
+
+				<Body className="bg-white my-auto mx-auto font-sans px-2">
+					<Container className="border border-solid border-[#eaeaea] rounded-lg my-[40px] mx-auto p-[20px] max-w-[465px]">
+						<Section className="mt-[32px]">
+							<Img
+								src={
+									"https://raw.githubusercontent.com/Dokploy/dokploy/canary/logo.png"
+								}
+								width="100"
+								height="50"
+								alt="Dokploy"
+								className="my-0 mx-auto"
+							/>
+						</Section>
+						<Heading className="text-black text-[24px] font-normal text-center p-0 my-[30px] mx-0">
+							Docker cleanup for <strong>dokploy</strong>
+						</Heading>
+						<Text className="text-black text-[14px] leading-[24px]">
+							Hello,
+						</Text>
+						<Text className="text-black text-[14px] leading-[24px]">
+							The docker cleanup for <strong>dokploy</strong> was successful ✅
+						</Text>
+
+						<Section className="flex text-black text-[14px]  leading-[24px] bg-[#F4F4F5] rounded-lg p-2">
+							<Text className="!leading-3 font-bold">Details: </Text>
+							<Text className="!leading-3">
+								Message: <strong>{message}</strong>
+							</Text>
+							<Text className="!leading-3">
+								Date: <strong>{date}</strong>
+							</Text>
+						</Section>
+					</Container>
+				</Body>
+			</Tailwind>
+		</Html>
+	);
+};
+
+export default DockerCleanupEmail;

packages/server/src/emails/emails/dokploy-restart.tsx

@@ -0,0 +1,75 @@
+import {
+	Body,
+	Container,
+	Head,
+	Heading,
+	Html,
+	Img,
+	Preview,
+	Section,
+	Tailwind,
+	Text,
+} from "@react-email/components";
+import * as React from "react";
+
+export type TemplateProps = {
+	date: string;
+};
+
+export const DokployRestartEmail = ({
+	date = "2023-05-01T00:00:00.000Z",
+}: TemplateProps) => {
+	const previewText = "Your dokploy server was restarted";
+	return (
+		<Html>
+			<Preview>{previewText}</Preview>
+			<Tailwind
+				config={{
+					theme: {
+						extend: {
+							colors: {
+								brand: "#007291",
+							},
+						},
+					},
+				}}
+			>
+				<Head />
+
+				<Body className="bg-white my-auto mx-auto font-sans px-2">
+					<Container className="border border-solid border-[#eaeaea] rounded-lg my-[40px] mx-auto p-[20px] max-w-[465px]">
+						<Section className="mt-[32px]">
+							<Img
+								src={
+									"https://raw.githubusercontent.com/Dokploy/dokploy/canary/logo.png"
+								}
+								width="100"
+								height="50"
+								alt="Dokploy"
+								className="my-0 mx-auto"
+							/>
+						</Section>
+						<Heading className="text-black text-[24px] font-normal text-center p-0 my-[30px] mx-0">
+							Dokploy Server Restart
+						</Heading>
+						<Text className="text-black text-[14px] leading-[24px]">
+							Hello,
+						</Text>
+						<Text className="text-black text-[14px] leading-[24px]">
+							Your dokploy server was restarted ✅
+						</Text>
+
+						<Section className="flex text-black text-[14px]  leading-[24px] bg-[#F4F4F5] rounded-lg p-2">
+							<Text className="!leading-3 font-bold">Details: </Text>
+							<Text className="!leading-3">
+								Date: <strong>{date}</strong>
+							</Text>
+						</Section>
+					</Container>
+				</Body>
+			</Tailwind>
+		</Html>
+	);
+};
+
+export default DokployRestartEmail;

packages/server/src/emails/emails/invitation.tsx

@@ -0,0 +1,98 @@
+import {
+	Body,
+	Button,
+	Container,
+	Head,
+	Heading,
+	Hr,
+	Html,
+	Img,
+	Link,
+	Preview,
+	Section,
+	Tailwind,
+	Text,
+} from "@react-email/components";
+
+export type TemplateProps = {
+	email: string;
+	name: string;
+};
+
+interface VercelInviteUserEmailProps {
+	inviteLink: string;
+	toEmail: string;
+}
+
+export const InvitationEmail = ({
+	inviteLink,
+	toEmail,
+}: VercelInviteUserEmailProps) => {
+	const previewText = "Join to Dokploy";
+	return (
+		<Html>
+			<Head />
+			<Preview>{previewText}</Preview>
+			<Tailwind
+				config={{
+					theme: {
+						extend: {
+							colors: {
+								brand: "#007291",
+							},
+						},
+					},
+				}}
+			>
+				<Body className="bg-white my-auto mx-auto font-sans px-2">
+					<Container className="border border-solid border-[#eaeaea] rounded-lg my-[40px] mx-auto p-[20px] max-w-[465px]">
+						<Section className="mt-[32px]">
+							<Img
+								src={
+									"https://raw.githubusercontent.com/Dokploy/dokploy/canary/logo.png"
+								}
+								width="100"
+								height="50"
+								alt="Dokploy"
+								className="my-0 mx-auto"
+							/>
+						</Section>
+						<Heading className="text-black text-[24px] font-normal text-center p-0 my-[30px] mx-0">
+							Join to <strong>Dokploy</strong>
+						</Heading>
+						<Text className="text-black text-[14px] leading-[24px]">
+							Hello,
+						</Text>
+						<Text className="text-black text-[14px] leading-[24px]">
+							You have been invited to join <strong>Dokploy</strong>, a platform
+							that helps for deploying your apps to the cloud.
+						</Text>
+						<Section className="text-center mt-[32px] mb-[32px]">
+							<Button
+								href={inviteLink}
+								className="bg-[#000000] rounded text-white text-[12px] font-semibold no-underline text-center px-5 py-3"
+							>
+								Join the team 🚀
+							</Button>
+						</Section>
+						<Text className="text-black text-[14px] leading-[24px]">
+							or copy and paste this URL into your browser:{" "}
+							<Link href={inviteLink} className="text-blue-600 no-underline">
+								https://dokploy.com
+							</Link>
+						</Text>
+						<Hr className="border border-solid border-[#eaeaea] my-[26px] mx-0 w-full" />
+						<Text className="text-[#666666] text-[12px] leading-[24px]">
+							This invitation was intended for {toEmail}. This invite was sent
+							from <strong className="text-black">dokploy.com</strong>. If you
+							were not expecting this invitation, you can ignore this email. If
+							you are concerned about your account's safety, please reply to
+						</Text>
+					</Container>
+				</Body>
+			</Tailwind>
+		</Html>
+	);
+};
+
+export default InvitationEmail;

packages/server/src/emails/emails/notion-magic-link.tsx

@@ -0,0 +1,150 @@
+import {
+	Body,
+	Container,
+	Head,
+	Heading,
+	Html,
+	Img,
+	Link,
+	Preview,
+	Text,
+} from "@react-email/components";
+import * as React from "react";
+
+interface NotionMagicLinkEmailProps {
+	loginCode?: string;
+}
+
+const baseUrl = process.env.VERCEL_URL
+	? `https://${process.env.VERCEL_URL}`
+	: "";
+
+export const NotionMagicLinkEmail = ({
+	loginCode,
+}: NotionMagicLinkEmailProps) => (
+	<Html>
+		<Head />
+		<Preview>Log in with this magic link</Preview>
+		<Body style={main}>
+			<Container style={container}>
+				<Heading style={h1}>Login</Heading>
+				<Link
+					href="https://notion.so"
+					target="_blank"
+					style={{
+						...link,
+						display: "block",
+						marginBottom: "16px",
+					}}
+				>
+					Click here to log in with this magic link
+				</Link>
+				<Text style={{ ...text, marginBottom: "14px" }}>
+					Or, copy and paste this temporary login code:
+				</Text>
+				<code style={code}>{loginCode}</code>
+				<Text
+					style={{
+						...text,
+						color: "#ababab",
+						marginTop: "14px",
+						marginBottom: "16px",
+					}}
+				>
+					If you didn&apos;t try to login, you can safely ignore this email.
+				</Text>
+				<Text
+					style={{
+						...text,
+						color: "#ababab",
+						marginTop: "12px",
+						marginBottom: "38px",
+					}}
+				>
+					Hint: You can set a permanent password in Settings & members → My
+					account.
+				</Text>
+				<Img
+					src={`${baseUrl}/static/notion-logo.png`}
+					width="32"
+					height="32"
+					alt="Notion's Logo"
+				/>
+				<Text style={footer}>
+					<Link
+						href="https://notion.so"
+						target="_blank"
+						style={{ ...link, color: "#898989" }}
+					>
+						Notion.so
+					</Link>
+					, the all-in-one-workspace
+					<br />
+					for your notes, tasks, wikis, and databases.
+				</Text>
+			</Container>
+		</Body>
+	</Html>
+);
+
+NotionMagicLinkEmail.PreviewProps = {
+	loginCode: "sparo-ndigo-amurt-secan",
+} as NotionMagicLinkEmailProps;
+
+export default NotionMagicLinkEmail;
+
+const main = {
+	backgroundColor: "#ffffff",
+};
+
+const container = {
+	paddingLeft: "12px",
+	paddingRight: "12px",
+	margin: "0 auto",
+};
+
+const h1 = {
+	color: "#333",
+	fontFamily:
+		"-apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue', sans-serif",
+	fontSize: "24px",
+	fontWeight: "bold",
+	margin: "40px 0",
+	padding: "0",
+};
+
+const link = {
+	color: "#2754C5",
+	fontFamily:
+		"-apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue', sans-serif",
+	fontSize: "14px",
+	textDecoration: "underline",
+};
+
+const text = {
+	color: "#333",
+	fontFamily:
+		"-apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue', sans-serif",
+	fontSize: "14px",
+	margin: "24px 0",
+};
+
+const footer = {
+	color: "#898989",
+	fontFamily:
+		"-apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue', sans-serif",
+	fontSize: "12px",
+	lineHeight: "22px",
+	marginTop: "12px",
+	marginBottom: "24px",
+};
+
+const code = {
+	display: "inline-block",
+	padding: "16px 4.5%",
+	width: "90.5%",
+	backgroundColor: "#f4f4f4",
+	borderRadius: "5px",
+	border: "1px solid #eee",
+	color: "#333",
+};

packages/server/src/emails/emails/plaid-verify-identity.tsx

@@ -0,0 +1,158 @@
+import {
+	Body,
+	Container,
+	Head,
+	Heading,
+	Html,
+	Img,
+	Link,
+	Section,
+	Text,
+} from "@react-email/components";
+import * as React from "react";
+
+interface PlaidVerifyIdentityEmailProps {
+	validationCode?: string;
+}
+
+const baseUrl = process.env.VERCEL_URL
+	? `https://${process.env.VERCEL_URL}`
+	: "";
+
+export const PlaidVerifyIdentityEmail = ({
+	validationCode,
+}: PlaidVerifyIdentityEmailProps) => (
+	<Html>
+		<Head />
+		<Body style={main}>
+			<Container style={container}>
+				<Img
+					src={`${baseUrl}/static/plaid-logo.png`}
+					width="212"
+					height="88"
+					alt="Plaid"
+					style={logo}
+				/>
+				<Text style={tertiary}>Verify Your Identity</Text>
+				<Heading style={secondary}>
+					Enter the following code to finish linking Venmo.
+				</Heading>
+				<Section style={codeContainer}>
+					<Text style={code}>{validationCode}</Text>
+				</Section>
+				<Text style={paragraph}>Not expecting this email?</Text>
+				<Text style={paragraph}>
+					Contact{" "}
+					<Link href="mailto:login@plaid.com" style={link}>
+						login@plaid.com
+					</Link>{" "}
+					if you did not request this code.
+				</Text>
+			</Container>
+			<Text style={footer}>Securely powered by Plaid.</Text>
+		</Body>
+	</Html>
+);
+
+PlaidVerifyIdentityEmail.PreviewProps = {
+	validationCode: "144833",
+} as PlaidVerifyIdentityEmailProps;
+
+export default PlaidVerifyIdentityEmail;
+
+const main = {
+	backgroundColor: "#ffffff",
+	fontFamily: "HelveticaNeue,Helvetica,Arial,sans-serif",
+};
+
+const container = {
+	backgroundColor: "#ffffff",
+	border: "1px solid #eee",
+	borderRadius: "5px",
+	boxShadow: "0 5px 10px rgba(20,50,70,.2)",
+	marginTop: "20px",
+	maxWidth: "360px",
+	margin: "0 auto",
+	padding: "68px 0 130px",
+};
+
+const logo = {
+	margin: "0 auto",
+};
+
+const tertiary = {
+	color: "#0a85ea",
+	fontSize: "11px",
+	fontWeight: 700,
+	fontFamily: "HelveticaNeue,Helvetica,Arial,sans-serif",
+	height: "16px",
+	letterSpacing: "0",
+	lineHeight: "16px",
+	margin: "16px 8px 8px 8px",
+	textTransform: "uppercase" as const,
+	textAlign: "center" as const,
+};
+
+const secondary = {
+	color: "#000",
+	display: "inline-block",
+	fontFamily: "HelveticaNeue-Medium,Helvetica,Arial,sans-serif",
+	fontSize: "20px",
+	fontWeight: 500,
+	lineHeight: "24px",
+	marginBottom: "0",
+	marginTop: "0",
+	textAlign: "center" as const,
+};
+
+const codeContainer = {
+	background: "rgba(0,0,0,.05)",
+	borderRadius: "4px",
+	margin: "16px auto 14px",
+	verticalAlign: "middle",
+	width: "280px",
+};
+
+const code = {
+	color: "#000",
+	display: "inline-block",
+	fontFamily: "HelveticaNeue-Bold",
+	fontSize: "32px",
+	fontWeight: 700,
+	letterSpacing: "6px",
+	lineHeight: "40px",
+	paddingBottom: "8px",
+	paddingTop: "8px",
+	margin: "0 auto",
+	width: "100%",
+	textAlign: "center" as const,
+};
+
+const paragraph = {
+	color: "#444",
+	fontSize: "15px",
+	fontFamily: "HelveticaNeue,Helvetica,Arial,sans-serif",
+	letterSpacing: "0",
+	lineHeight: "23px",
+	padding: "0 40px",
+	margin: "0",
+	textAlign: "center" as const,
+};
+
+const link = {
+	color: "#444",
+	textDecoration: "underline",
+};
+
+const footer = {
+	color: "#000",
+	fontSize: "12px",
+	fontWeight: 800,
+	letterSpacing: "0",
+	lineHeight: "23px",
+	margin: "0",
+	marginTop: "20px",
+	fontFamily: "HelveticaNeue,Helvetica,Arial,sans-serif",
+	textAlign: "center" as const,
+	textTransform: "uppercase" as const,
+};

packages/server/src/emails/emails/stripe-welcome.tsx

@@ -0,0 +1,152 @@
+import {
+	Body,
+	Button,
+	Container,
+	Head,
+	Hr,
+	Html,
+	Img,
+	Link,
+	Preview,
+	Section,
+	Text,
+} from "@react-email/components";
+import * as React from "react";
+
+const baseUrl = process.env.VERCEL_URL
+	? `https://${process.env.VERCEL_URL}`
+	: "";
+
+export const StripeWelcomeEmail = () => (
+	<Html>
+		<Head />
+		<Preview>You're now ready to make live transactions with Stripe!</Preview>
+		<Body style={main}>
+			<Container style={container}>
+				<Section style={box}>
+					<Img
+						src={`${baseUrl}/static/stripe-logo.png`}
+						width="49"
+						height="21"
+						alt="Stripe"
+					/>
+					<Hr style={hr} />
+					<Text style={paragraph}>
+						Thanks for submitting your account information. You're now ready to
+						make live transactions with Stripe!
+					</Text>
+					<Text style={paragraph}>
+						You can view your payments and a variety of other information about
+						your account right from your dashboard.
+					</Text>
+					<Button style={button} href="https://dashboard.stripe.com/login">
+						View your Stripe Dashboard
+					</Button>
+					<Hr style={hr} />
+					<Text style={paragraph}>
+						If you haven't finished your integration, you might find our{" "}
+						<Link style={anchor} href="https://stripe.com/docs">
+							docs
+						</Link>{" "}
+						handy.
+					</Text>
+					<Text style={paragraph}>
+						Once you're ready to start accepting payments, you'll just need to
+						use your live{" "}
+						<Link
+							style={anchor}
+							href="https://dashboard.stripe.com/login?redirect=%2Fapikeys"
+						>
+							API keys
+						</Link>{" "}
+						instead of your test API keys. Your account can simultaneously be
+						used for both test and live requests, so you can continue testing
+						while accepting live payments. Check out our{" "}
+						<Link style={anchor} href="https://stripe.com/docs/dashboard">
+							tutorial about account basics
+						</Link>
+						.
+					</Text>
+					<Text style={paragraph}>
+						Finally, we've put together a{" "}
+						<Link
+							style={anchor}
+							href="https://stripe.com/docs/checklist/website"
+						>
+							quick checklist
+						</Link>{" "}
+						to ensure your website conforms to card network standards.
+					</Text>
+					<Text style={paragraph}>
+						We'll be here to help you with any step along the way. You can find
+						answers to most questions and get in touch with us on our{" "}
+						<Link style={anchor} href="https://support.stripe.com/">
+							support site
+						</Link>
+						.
+					</Text>
+					<Text style={paragraph}>— The Stripe team</Text>
+					<Hr style={hr} />
+					<Text style={footer}>
+						Stripe, 354 Oyster Point Blvd, South San Francisco, CA 94080
+					</Text>
+				</Section>
+			</Container>
+		</Body>
+	</Html>
+);
+
+export default StripeWelcomeEmail;
+
+const main = {
+	backgroundColor: "#f6f9fc",
+	fontFamily:
+		'-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Ubuntu,sans-serif',
+};
+
+const container = {
+	backgroundColor: "#ffffff",
+	margin: "0 auto",
+	padding: "20px 0 48px",
+	marginBottom: "64px",
+};
+
+const box = {
+	padding: "0 48px",
+};
+
+const hr = {
+	borderColor: "#e6ebf1",
+	margin: "20px 0",
+};
+
+const paragraph = {
+	color: "#525f7f",
+
+	fontSize: "16px",
+	lineHeight: "24px",
+	textAlign: "left" as const,
+};
+
+const anchor = {
+	color: "#556cd6",
+};
+
+const button = {
+	backgroundColor: "#656ee8",
+	borderRadius: "5px",
+	color: "#fff",
+	fontSize: "16px",
+	fontWeight: "bold",
+	textDecoration: "none",
+	textAlign: "center" as const,
+	display: "block",
+	width: "100%",
+	padding: "10px",
+};
+
+const footer = {
+	color: "#8898aa",
+	fontSize: "12px",
+	lineHeight: "16px",
+};

packages/server/src/emails/emails/vercel-invite-user.tsx

@@ -0,0 +1,154 @@
+import {
+	Body,
+	Button,
+	Column,
+	Container,
+	Head,
+	Heading,
+	Hr,
+	Html,
+	Img,
+	Link,
+	Preview,
+	Row,
+	Section,
+	Tailwind,
+	Text,
+} from "@react-email/components";
+import * as React from "react";
+
+interface VercelInviteUserEmailProps {
+	username?: string;
+	userImage?: string;
+	invitedByUsername?: string;
+	invitedByEmail?: string;
+	teamName?: string;
+	teamImage?: string;
+	inviteLink?: string;
+	inviteFromIp?: string;
+	inviteFromLocation?: string;
+}
+
+const baseUrl = process.env.VERCEL_URL
+	? `https://${process.env.VERCEL_URL}`
+	: "";
+
+export const VercelInviteUserEmail = ({
+	username,
+	userImage,
+	invitedByUsername,
+	invitedByEmail,
+	teamName,
+	teamImage,
+	inviteLink,
+	inviteFromIp,
+	inviteFromLocation,
+}: VercelInviteUserEmailProps) => {
+	const previewText = `Join ${invitedByUsername} on Vercel`;
+
+	return (
+		<Html>
+			<Head />
+			<Preview>{previewText}</Preview>
+			<Tailwind>
+				<Body className="bg-white my-auto mx-auto font-sans px-2">
+					<Container className="border border-solid border-[#eaeaea] rounded my-[40px] mx-auto p-[20px] max-w-[465px]">
+						<Section className="mt-[32px]">
+							<Img
+								src={`${baseUrl}/static/vercel-logo.png`}
+								width="40"
+								height="37"
+								alt="Vercel"
+								className="my-0 mx-auto"
+							/>
+						</Section>
+						<Heading className="text-black text-[24px] font-normal text-center p-0 my-[30px] mx-0">
+							Join <strong>{teamName}</strong> on <strong>Vercel</strong>
+						</Heading>
+						<Text className="text-black text-[14px] leading-[24px]">
+							Hello {username},
+						</Text>
+						<Text className="text-black text-[14px] leading-[24px]">
+							<strong>{invitedByUsername}</strong> (
+							<Link
+								href={`mailto:${invitedByEmail}`}
+								className="text-blue-600 no-underline"
+							>
+								{invitedByEmail}
+							</Link>
+							) has invited you to the <strong>{teamName}</strong> team on{" "}
+							<strong>Vercel</strong>.
+						</Text>
+						<Section>
+							<Row>
+								<Column align="right">
+									<Img
+										className="rounded-full"
+										src={userImage}
+										width="64"
+										height="64"
+									/>
+								</Column>
+								<Column align="center">
+									<Img
+										src={`${baseUrl}/static/vercel-arrow.png`}
+										width="12"
+										height="9"
+										alt="invited you to"
+									/>
+								</Column>
+								<Column align="left">
+									<Img
+										className="rounded-full"
+										src={teamImage}
+										width="64"
+										height="64"
+									/>
+								</Column>
+							</Row>
+						</Section>
+						<Section className="text-center mt-[32px] mb-[32px]">
+							<Button
+								className="bg-[#000000] rounded text-white text-[12px] font-semibold no-underline text-center px-5 py-3"
+								href={inviteLink}
+							>
+								Join the team
+							</Button>
+						</Section>
+						<Text className="text-black text-[14px] leading-[24px]">
+							or copy and paste this URL into your browser:{" "}
+							<Link href={inviteLink} className="text-blue-600 no-underline">
+								{inviteLink}
+							</Link>
+						</Text>
+						<Hr className="border border-solid border-[#eaeaea] my-[26px] mx-0 w-full" />
+						<Text className="text-[#666666] text-[12px] leading-[24px]">
+							This invitation was intended for{" "}
+							<span className="text-black">{username}</span>. This invite was
+							sent from <span className="text-black">{inviteFromIp}</span>{" "}
+							located in{" "}
+							<span className="text-black">{inviteFromLocation}</span>. If you
+							were not expecting this invitation, you can ignore this email. If
+							you are concerned about your account's safety, please reply to
+							this email to get in touch with us.
+						</Text>
+					</Container>
+				</Body>
+			</Tailwind>
+		</Html>
+	);
+};
+
+VercelInviteUserEmail.PreviewProps = {
+	username: "alanturing",
+	userImage: `${baseUrl}/static/vercel-user.png`,
+	invitedByUsername: "Alan",
+	invitedByEmail: "alan.turing@example.com",
+	teamName: "Enigma",
+	teamImage: `${baseUrl}/static/vercel-team.png`,
+	inviteLink: "https://vercel.com/teams/invite/foo",
+	inviteFromIp: "204.13.186.218",
+	inviteFromLocation: "São Paulo, Brazil",
+} as VercelInviteUserEmailProps;
+
+export default VercelInviteUserEmail;

packages/server/src/emails/package.json

@@ -0,0 +1,20 @@
+{
+	"name": "emails",
+	"version": "0.0.19",
+	"private": true,
+	"type": "module",
+	"scripts": {
+		"build": "email build",
+		"dev": "email dev",
+		"export": "email export"
+	},
+	"dependencies": {
+		"@react-email/components": "0.0.21",
+		"react-email": "2.1.5",
+		"react": "^18.2.0"
+	},
+	"devDependencies": {
+		"@types/react": "18.2.33",
+		"@types/react-dom": "18.2.14"
+	}
+}

packages/server/src/emails/readme.md

@@ -0,0 +1,27 @@
+# React Email Starter
+
+A live preview right in your browser so you don't need to keep sending real emails during development.
+
+## Getting Started
+
+First, install the dependencies:
+
+```sh
+npm install
+# or
+yarn
+```
+
+Then, run the development server:
+
+```sh
+npm run dev
+# or
+yarn dev
+```
+
+Open [localhost:3000](http://localhost:3000) with your browser to see the result.
+
+## License
+
+MIT License

packages/server/src/index.ts

@@ -0,0 +1,120 @@
+export * from "./auth/auth";
+export * from "./auth/token";
+export * from "./auth/random-password";
+// export * from "./db";
+export * from "./services/admin";
+export * from "./services/user";
+export * from "./services/project";
+export * from "./services/postgres";
+export * from "./services/domain";
+export * from "./services/mariadb";
+export * from "./services/mongo";
+export * from "./services/mysql";
+export * from "./services/backup";
+export * from "./services/cluster";
+export * from "./services/settings";
+export * from "./services/docker";
+export * from "./services/destination";
+export * from "./services/deployment";
+export * from "./services/mount";
+export * from "./services/certificate";
+export * from "./services/redirect";
+export * from "./services/security";
+export * from "./services/port";
+export * from "./services/redis";
+export * from "./services/compose";
+export * from "./services/registry";
+export * from "./services/notification";
+export * from "./services/ssh-key";
+export * from "./services/git-provider";
+export * from "./services/bitbucket";
+export * from "./services/github";
+export * from "./services/auth";
+export * from "./services/gitlab";
+export * from "./services/server";
+export * from "./services/application";
+
+export * from "./setup/config-paths";
+export * from "./setup/postgres-setup";
+export * from "./setup/redis-setup";
+export * from "./setup/registry-setup";
+export * from "./setup/server-setup";
+export * from "./setup/setup";
+export * from "./setup/traefik-setup";
+
+export * from "./utils/backups/index";
+export * from "./utils/backups/mariadb";
+export * from "./utils/backups/mongo";
+export * from "./utils/backups/mysql";
+export * from "./utils/backups/postgres";
+export * from "./utils/backups/utils";
+
+export * from "./utils/notifications/build-error";
+export * from "./utils/notifications/build-success";
+export * from "./utils/notifications/database-backup";
+export * from "./utils/notifications/dokploy-restart";
+export * from "./utils/notifications/utils";
+export * from "./utils/notifications/docker-cleanup";
+
+export * from "./utils/builders/index";
+export * from "./utils/builders/compose";
+export * from "./utils/builders/docker-file";
+export * from "./utils/builders/drop";
+export * from "./utils/builders/heroku";
+export * from "./utils/builders/nixpacks";
+export * from "./utils/builders/paketo";
+export * from "./utils/builders/static";
+export * from "./utils/builders/utils";
+
+export * from "./utils/cluster/upload";
+
+export * from "./utils/docker/compose";
+export * from "./utils/docker/domain";
+export * from "./utils/docker/utils";
+export * from "./utils/docker/types";
+export * from "./utils/docker/compose/configs";
+export * from "./utils/docker/compose/network";
+export * from "./utils/docker/compose/secrets";
+export * from "./utils/docker/compose/service";
+export * from "./utils/docker/compose/volume";
+
+export * from "./utils/filesystem/directory";
+export * from "./utils/filesystem/ssh";
+
+export * from "./utils/process/execAsync";
+export * from "./utils/process/spawnAsync";
+export * from "./utils/providers/bitbucket";
+export * from "./utils/providers/docker";
+export * from "./utils/providers/git";
+export * from "./utils/providers/github";
+export * from "./utils/providers/gitlab";
+export * from "./utils/providers/raw";
+
+export * from "./utils/servers/remote-docker";
+
+export * from "./utils/traefik/application";
+export * from "./utils/traefik/domain";
+export * from "./utils/traefik/file-types";
+export * from "./utils/traefik/middleware";
+export * from "./utils/traefik/redirect";
+export * from "./utils/traefik/registry";
+export * from "./utils/traefik/security";
+export * from "./utils/traefik/types";
+export * from "./utils/traefik/web-server";
+
+export * from "./wss/docker-container-logs";
+export * from "./wss/docker-container-terminal";
+export * from "./wss/docker-stats";
+export * from "./wss/listen-deployment";
+export * from "./wss/terminal";
+export * from "./wss/utils";
+
+export * from "./utils/access-log/handler";
+export * from "./utils/access-log/types";
+export * from "./utils/access-log/utils";
+export * from "./constants/index";
+
+export * from "./monitoring/utilts";
+
+export * from "./db/validations/domain";
+export * from "./db/validations/index";

packages/server/src/monitoring/utilts.ts

@@ -0,0 +1,198 @@
+import { promises } from "node:fs";
+import type Dockerode from "dockerode";
+import osUtils from "node-os-utils";
+import { paths } from "../constants";
+
+export const recordAdvancedStats = async (
+	stats: Dockerode.ContainerStats,
+	appName: string,
+) => {
+	const { MONITORING_PATH } = paths();
+	const path = `${MONITORING_PATH}/${appName}`;
+
+	await promises.mkdir(path, { recursive: true });
+
+	const cpuPercent = calculateCpuUsagePercent(
+		stats.cpu_stats,
+		stats.precpu_stats,
+	);
+	const memoryStats = calculateMemoryStats(stats.memory_stats);
+	const blockIO = calculateBlockIO(stats.blkio_stats);
+	const networkUsage = calculateNetworkUsage(stats.networks);
+
+	await updateStatsFile(appName, "cpu", cpuPercent);
+	await updateStatsFile(appName, "memory", {
+		used: memoryStats.used,
+		free: memoryStats.free,
+		usedPercentage: memoryStats.usedPercentage,
+		total: memoryStats.total,
+	});
+	await updateStatsFile(appName, "block", {
+		readMb: blockIO.readMb,
+		writeMb: blockIO.writeMb,
+	});
+
+	await updateStatsFile(appName, "network", {
+		inputMb: networkUsage.inputMb,
+		outputMb: networkUsage.outputMb,
+	});
+
+	if (appName === "dokploy") {
+		const disk = await osUtils.drive.info("/");
+
+		const diskUsage = disk.usedGb;
+		const diskTotal = disk.totalGb;
+		const diskUsedPercentage = disk.usedPercentage;
+		const diskFree = disk.freeGb;
+
+		await updateStatsFile(appName, "disk", {
+			diskTotal: +diskTotal,
+			diskUsedPercentage: +diskUsedPercentage,
+			diskUsage: +diskUsage,
+			diskFree: +diskFree,
+		});
+	}
+};
+
+export const getAdvancedStats = async (appName: string) => {
+	return {
+		cpu: await readStatsFile(appName, "cpu"),
+		memory: await readStatsFile(appName, "memory"),
+		disk: await readStatsFile(appName, "disk"),
+		network: await readStatsFile(appName, "network"),
+		block: await readStatsFile(appName, "block"),
+	};
+};
+
+export const readStatsFile = async (
+	appName: string,
+	statType: "cpu" | "memory" | "disk" | "network" | "block",
+) => {
+	try {
+		const { MONITORING_PATH } = paths();
+		const filePath = `${MONITORING_PATH}/${appName}/${statType}.json`;
+		const data = await promises.readFile(filePath, "utf-8");
+		return JSON.parse(data);
+	} catch (error) {
+		return [];
+	}
+};
+
+export const updateStatsFile = async (
+	appName: string,
+	statType: "cpu" | "memory" | "disk" | "network" | "block",
+	value: number | string | unknown,
+) => {
+	const { MONITORING_PATH } = paths();
+	const stats = await readStatsFile(appName, statType);
+	stats.push({ value, time: new Date() });
+
+	if (stats.length > 288) {
+		stats.shift();
+	}
+
+	const content = JSON.stringify(stats);
+	await promises.writeFile(
+		`${MONITORING_PATH}/${appName}/${statType}.json`,
+		content,
+	);
+};
+
+export const readLastValueStatsFile = async (
+	appName: string,
+	statType: "cpu" | "memory" | "disk" | "network" | "block",
+) => {
+	try {
+		const { MONITORING_PATH } = paths();
+		const filePath = `${MONITORING_PATH}/${appName}/${statType}.json`;
+		const data = await promises.readFile(filePath, "utf-8");
+		const stats = JSON.parse(data);
+		return stats[stats.length - 1] || null;
+	} catch (error) {
+		return null;
+	}
+};
+
+export const getLastAdvancedStatsFile = async (appName: string) => {
+	return {
+		cpu: await readLastValueStatsFile(appName, "cpu"),
+		memory: await readLastValueStatsFile(appName, "memory"),
+		disk: await readLastValueStatsFile(appName, "disk"),
+		network: await readLastValueStatsFile(appName, "network"),
+		block: await readLastValueStatsFile(appName, "block"),
+	};
+};
+
+const calculateCpuUsagePercent = (
+	cpu_stats: Dockerode.ContainerStats["cpu_stats"],
+	precpu_stats: Dockerode.ContainerStats["precpu_stats"],
+) => {
+	const cpuDelta =
+		cpu_stats.cpu_usage.total_usage - precpu_stats.cpu_usage.total_usage;
+	const systemDelta =
+		cpu_stats.system_cpu_usage - precpu_stats.system_cpu_usage;
+
+	const numberCpus =
+		cpu_stats.online_cpus ||
+		(cpu_stats.cpu_usage.percpu_usage
+			? cpu_stats.cpu_usage.percpu_usage.length
+			: 1);
+
+	if (systemDelta > 0 && cpuDelta > 0) {
+		return (cpuDelta / systemDelta) * numberCpus * 100.0;
+	}
+	return 0;
+};
+
+const calculateMemoryStats = (
+	memory_stats: Dockerode.ContainerStats["memory_stats"],
+) => {
+	const usedMemory = memory_stats.usage - (memory_stats.stats.cache || 0);
+	const availableMemory = memory_stats.limit;
+	const memoryUsedPercentage = (usedMemory / availableMemory) * 100.0;
+
+	return {
+		used: usedMemory,
+		free: availableMemory - usedMemory,
+		usedPercentage: memoryUsedPercentage,
+		total: availableMemory,
+	};
+};
+const calculateBlockIO = (
+	blkio_stats: Dockerode.ContainerStats["blkio_stats"],
+) => {
+	let readIO = 0;
+	let writeIO = 0;
+	if (blkio_stats?.io_service_bytes_recursive) {
+		for (const io of blkio_stats.io_service_bytes_recursive) {
+			if (io.op === "read") {
+				readIO += io.value;
+			} else if (io.op === "write") {
+				writeIO += io.value;
+			}
+		}
+	}
+	return {
+		readMb: readIO / (1024 * 1024),
+		writeMb: writeIO / (1024 * 1024),
+	};
+};
+
+const calculateNetworkUsage = (
+	networks: Dockerode.ContainerStats["networks"],
+) => {
+	let totalRx = 0;
+	let totalTx = 0;
+
+	const stats = Object.keys(networks);
+
+	for (const interfaceName of stats) {
+		const net = networks[interfaceName];
+		totalRx += net?.rx_bytes || 0;
+		totalTx += net?.tx_bytes || 0;
+	}
+	return {
+		inputMb: totalRx / (1024 * 1024),
+		outputMb: totalTx / (1024 * 1024),
+	};
+};

packages/server/src/services/admin.ts

@@ -0,0 +1,150 @@
+import { randomBytes } from "node:crypto";
+import { db } from "@/server/db";
+import {
+	admins,
+	type apiCreateUserInvitation,
+	auth,
+	users,
+} from "@/server/db/schema";
+import { TRPCError } from "@trpc/server";
+import * as bcrypt from "bcrypt";
+import { eq } from "drizzle-orm";
+
+export type Admin = typeof admins.$inferSelect;
+export const createInvitation = async (
+	input: typeof apiCreateUserInvitation._type,
+	adminId: string,
+) => {
+	await db.transaction(async (tx) => {
+		const result = await tx
+			.insert(auth)
+			.values({
+				email: input.email,
+				rol: "user",
+				password: bcrypt.hashSync("01231203012312", 10),
+			})
+			.returning()
+			.then((res) => res[0]);
+
+		if (!result) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: "Error to create the user",
+			});
+		}
+		const expiresIn24Hours = new Date();
+		expiresIn24Hours.setDate(expiresIn24Hours.getDate() + 1);
+		const token = randomBytes(32).toString("hex");
+		await tx
+			.insert(users)
+			.values({
+				adminId: adminId,
+				authId: result.id,
+				token,
+				expirationDate: expiresIn24Hours.toISOString(),
+			})
+			.returning();
+	});
+};
+
+export const findAdminById = async (adminId: string) => {
+	const admin = await db.query.admins.findFirst({
+		where: eq(admins.adminId, adminId),
+	});
+	if (!admin) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Admin not found",
+		});
+	}
+	return admin;
+};
+
+export const updateAdmin = async (
+	authId: string,
+	adminData: Partial<Admin>,
+) => {
+	const admin = await db
+		.update(admins)
+		.set({
+			...adminData,
+		})
+		.where(eq(admins.authId, authId))
+		.returning()
+		.then((res) => res[0]);
+
+	return admin;
+};
+
+export const isAdminPresent = async () => {
+	const admin = await db.query.admins.findFirst();
+	if (!admin) {
+		return false;
+	}
+	return true;
+};
+
+export const findAdminByAuthId = async (authId: string) => {
+	const admin = await db.query.admins.findFirst({
+		where: eq(admins.authId, authId),
+	});
+	if (!admin) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Admin not found",
+		});
+	}
+	return admin;
+};
+
+export const findAdmin = async () => {
+	const admin = await db.query.admins.findFirst({});
+	if (!admin) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Admin not found",
+		});
+	}
+	return admin;
+};
+
+export const getUserByToken = async (token: string) => {
+	const user = await db.query.users.findFirst({
+		where: eq(users.token, token),
+		with: {
+			auth: {
+				columns: {
+					password: false,
+				},
+			},
+		},
+	});
+
+	if (!user) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Invitation not found",
+		});
+	}
+	return {
+		...user,
+		isExpired: user.isRegistered,
+	};
+};
+
+export const removeUserByAuthId = async (authId: string) => {
+	await db
+		.delete(auth)
+		.where(eq(auth.id, authId))
+		.returning()
+		.then((res) => res[0]);
+};
+
+export const getDokployUrl = async () => {
+	const admin = await findAdmin();
+
+	if (admin.host) {
+		return `https://${admin.host}`;
+	}
+	return `http://${admin.serverIp}:${process.env.PORT}`;
+};

packages/server/src/services/application.ts

@@ -0,0 +1,394 @@
+import { docker } from "@/server/constants";
+import { db } from "@/server/db";
+import { type apiCreateApplication, applications } from "@/server/db/schema";
+import { generateAppName } from "@/server/db/schema";
+import { getAdvancedStats } from "@/server/monitoring/utilts";
+import { generatePassword } from "@/server/templates/utils";
+import {
+	buildApplication,
+	getBuildCommand,
+	mechanizeDockerContainer,
+} from "@/server/utils/builders";
+import { sendBuildErrorNotifications } from "@/server/utils/notifications/build-error";
+import { sendBuildSuccessNotifications } from "@/server/utils/notifications/build-success";
+import { execAsyncRemote } from "@/server/utils/process/execAsync";
+import {
+	cloneBitbucketRepository,
+	getBitbucketCloneCommand,
+} from "@/server/utils/providers/bitbucket";
+import {
+	buildDocker,
+	buildRemoteDocker,
+} from "@/server/utils/providers/docker";
+import {
+	cloneGitRepository,
+	getCustomGitCloneCommand,
+} from "@/server/utils/providers/git";
+import {
+	cloneGithubRepository,
+	getGithubCloneCommand,
+} from "@/server/utils/providers/github";
+import {
+	cloneGitlabRepository,
+	getGitlabCloneCommand,
+} from "@/server/utils/providers/gitlab";
+import { createTraefikConfig } from "@/server/utils/traefik/application";
+import { TRPCError } from "@trpc/server";
+import { eq } from "drizzle-orm";
+import { getDokployUrl } from "./admin";
+import { createDeployment, updateDeploymentStatus } from "./deployment";
+import { validUniqueServerAppName } from "./project";
+export type Application = typeof applications.$inferSelect;
+
+export const createApplication = async (
+	input: typeof apiCreateApplication._type,
+) => {
+	input.appName =
+		`${input.appName}-${generatePassword(6)}` || generateAppName("app");
+	if (input.appName) {
+		const valid = await validUniqueServerAppName(input.appName);
+
+		if (!valid) {
+			throw new TRPCError({
+				code: "CONFLICT",
+				message: "Application with this 'AppName' already exists",
+			});
+		}
+	}
+
+	return await db.transaction(async (tx) => {
+		const newApplication = await tx
+			.insert(applications)
+			.values({
+				...input,
+			})
+			.returning()
+			.then((value) => value[0]);
+
+		if (!newApplication) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: "Error to create the application",
+			});
+		}
+
+		if (process.env.NODE_ENV === "development") {
+			createTraefikConfig(newApplication.appName);
+		}
+
+		return newApplication;
+	});
+};
+
+export const findApplicationById = async (applicationId: string) => {
+	const application = await db.query.applications.findFirst({
+		where: eq(applications.applicationId, applicationId),
+		with: {
+			project: true,
+			domains: true,
+			deployments: true,
+			mounts: true,
+			redirects: true,
+			security: true,
+			ports: true,
+			registry: true,
+			gitlab: true,
+			github: true,
+			bitbucket: true,
+			server: true,
+		},
+	});
+	if (!application) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Application not found",
+		});
+	}
+	return application;
+};
+
+export const findApplicationByName = async (appName: string) => {
+	const application = await db.query.applications.findFirst({
+		where: eq(applications.appName, appName),
+	});
+
+	return application;
+};
+
+export const updateApplication = async (
+	applicationId: string,
+	applicationData: Partial<Application>,
+) => {
+	const application = await db
+		.update(applications)
+		.set({
+			...applicationData,
+		})
+		.where(eq(applications.applicationId, applicationId))
+		.returning();
+
+	return application[0];
+};
+
+export const updateApplicationStatus = async (
+	applicationId: string,
+	applicationStatus: Application["applicationStatus"],
+) => {
+	const application = await db
+		.update(applications)
+		.set({
+			applicationStatus: applicationStatus,
+		})
+		.where(eq(applications.applicationId, applicationId))
+		.returning();
+
+	return application;
+};
+
+export const deployApplication = async ({
+	applicationId,
+	titleLog = "Manual deployment",
+	descriptionLog = "",
+}: {
+	applicationId: string;
+	titleLog: string;
+	descriptionLog: string;
+}) => {
+	const application = await findApplicationById(applicationId);
+	const buildLink = `${await getDokployUrl()}/dashboard/project/${application.projectId}/services/application/${application.applicationId}?tab=deployments`;
+	const deployment = await createDeployment({
+		applicationId: applicationId,
+		title: titleLog,
+		description: descriptionLog,
+	});
+
+	try {
+		if (application.sourceType === "github") {
+			await cloneGithubRepository(application, deployment.logPath);
+			await buildApplication(application, deployment.logPath);
+		} else if (application.sourceType === "gitlab") {
+			await cloneGitlabRepository(application, deployment.logPath);
+			await buildApplication(application, deployment.logPath);
+		} else if (application.sourceType === "bitbucket") {
+			await cloneBitbucketRepository(application, deployment.logPath);
+			await buildApplication(application, deployment.logPath);
+		} else if (application.sourceType === "docker") {
+			await buildDocker(application, deployment.logPath);
+		} else if (application.sourceType === "git") {
+			await cloneGitRepository(application, deployment.logPath);
+			await buildApplication(application, deployment.logPath);
+		} else if (application.sourceType === "drop") {
+			await buildApplication(application, deployment.logPath);
+		}
+
+		await updateDeploymentStatus(deployment.deploymentId, "done");
+		await updateApplicationStatus(applicationId, "done");
+
+		await sendBuildSuccessNotifications({
+			projectName: application.project.name,
+			applicationName: application.name,
+			applicationType: "application",
+			buildLink,
+		});
+	} catch (error) {
+		await updateDeploymentStatus(deployment.deploymentId, "error");
+		await updateApplicationStatus(applicationId, "error");
+		await sendBuildErrorNotifications({
+			projectName: application.project.name,
+			applicationName: application.name,
+			applicationType: "application",
+			// @ts-ignore
+			errorMessage: error?.message || "Error to build",
+			buildLink,
+		});
+
+		console.log(
+			"Error on ",
+			application.buildType,
+			"/",
+			application.sourceType,
+			error,
+		);
+
+		throw error;
+	}
+
+	return true;
+};
+
+export const rebuildApplication = async ({
+	applicationId,
+	titleLog = "Rebuild deployment",
+	descriptionLog = "",
+}: {
+	applicationId: string;
+	titleLog: string;
+	descriptionLog: string;
+}) => {
+	const application = await findApplicationById(applicationId);
+	const deployment = await createDeployment({
+		applicationId: applicationId,
+		title: titleLog,
+		description: descriptionLog,
+	});
+
+	try {
+		if (application.sourceType === "github") {
+			await buildApplication(application, deployment.logPath);
+		} else if (application.sourceType === "gitlab") {
+			await buildApplication(application, deployment.logPath);
+		} else if (application.sourceType === "bitbucket") {
+			await buildApplication(application, deployment.logPath);
+		} else if (application.sourceType === "docker") {
+			await buildDocker(application, deployment.logPath);
+		} else if (application.sourceType === "git") {
+			await buildApplication(application, deployment.logPath);
+		} else if (application.sourceType === "drop") {
+			await buildApplication(application, deployment.logPath);
+		}
+		await updateDeploymentStatus(deployment.deploymentId, "done");
+		await updateApplicationStatus(applicationId, "done");
+	} catch (error) {
+		await updateDeploymentStatus(deployment.deploymentId, "error");
+		await updateApplicationStatus(applicationId, "error");
+		throw error;
+	}
+
+	return true;
+};
+
+export const deployRemoteApplication = async ({
+	applicationId,
+	titleLog = "Manual deployment",
+	descriptionLog = "",
+}: {
+	applicationId: string;
+	titleLog: string;
+	descriptionLog: string;
+}) => {
+	const application = await findApplicationById(applicationId);
+	const buildLink = `${await getDokployUrl()}/dashboard/project/${application.projectId}/services/application/${application.applicationId}?tab=deployments`;
+	const deployment = await createDeployment({
+		applicationId: applicationId,
+		title: titleLog,
+		description: descriptionLog,
+	});
+
+	try {
+		if (application.serverId) {
+			let command = "set -e;";
+			if (application.sourceType === "github") {
+				command += await getGithubCloneCommand(application, deployment.logPath);
+			} else if (application.sourceType === "gitlab") {
+				command += await getGitlabCloneCommand(application, deployment.logPath);
+			} else if (application.sourceType === "bitbucket") {
+				command += await getBitbucketCloneCommand(
+					application,
+					deployment.logPath,
+				);
+			} else if (application.sourceType === "git") {
+				command += await getCustomGitCloneCommand(
+					application,
+					deployment.logPath,
+				);
+			} else if (application.sourceType === "docker") {
+				command += await buildRemoteDocker(application, deployment.logPath);
+			}
+
+			if (application.sourceType !== "docker") {
+				command += getBuildCommand(application, deployment.logPath);
+			}
+			await execAsyncRemote(application.serverId, command);
+			await mechanizeDockerContainer(application);
+		}
+
+		await updateDeploymentStatus(deployment.deploymentId, "done");
+		await updateApplicationStatus(applicationId, "done");
+
+		await sendBuildSuccessNotifications({
+			projectName: application.project.name,
+			applicationName: application.name,
+			applicationType: "application",
+			buildLink,
+		});
+	} catch (error) {
+		await updateDeploymentStatus(deployment.deploymentId, "error");
+		await updateApplicationStatus(applicationId, "error");
+		await sendBuildErrorNotifications({
+			projectName: application.project.name,
+			applicationName: application.name,
+			applicationType: "application",
+			// @ts-ignore
+			errorMessage: error?.message || "Error to build",
+			buildLink,
+		});
+
+		console.log(
+			"Error on ",
+			application.buildType,
+			"/",
+			application.sourceType,
+			error,
+		);
+
+		throw error;
+	}
+
+	return true;
+};
+
+export const rebuildRemoteApplication = async ({
+	applicationId,
+	titleLog = "Rebuild deployment",
+	descriptionLog = "",
+}: {
+	applicationId: string;
+	titleLog: string;
+	descriptionLog: string;
+}) => {
+	const application = await findApplicationById(applicationId);
+	const deployment = await createDeployment({
+		applicationId: applicationId,
+		title: titleLog,
+		description: descriptionLog,
+	});
+
+	try {
+		if (application.serverId) {
+			if (application.sourceType !== "docker") {
+				let command = "set -e;";
+				command += getBuildCommand(application, deployment.logPath);
+				await execAsyncRemote(application.serverId, command);
+			}
+			await mechanizeDockerContainer(application);
+		}
+		await updateDeploymentStatus(deployment.deploymentId, "done");
+		await updateApplicationStatus(applicationId, "done");
+	} catch (error) {
+		await updateDeploymentStatus(deployment.deploymentId, "error");
+		await updateApplicationStatus(applicationId, "error");
+		throw error;
+	}
+
+	return true;
+};
+
+export const getApplicationStats = async (appName: string) => {
+	const filter = {
+		status: ["running"],
+		label: [`com.docker.swarm.service.name=${appName}`],
+	};
+
+	const containers = await docker.listContainers({
+		filters: JSON.stringify(filter),
+	});
+
+	const container = containers[0];
+	if (!container || container?.State !== "running") {
+		return null;
+	}
+
+	const data = await getAdvancedStats(appName);
+
+	return data;
+};

packages/server/src/services/auth.ts

@@ -0,0 +1,184 @@
+import { randomBytes } from "node:crypto";
+import { db } from "@/server/db";
+import {
+	admins,
+	type apiCreateAdmin,
+	type apiCreateUser,
+	auth,
+	users,
+} from "@/server/db/schema";
+import { getPublicIpWithFallback } from "@/server/wss/terminal";
+import { TRPCError } from "@trpc/server";
+import * as bcrypt from "bcrypt";
+import { eq } from "drizzle-orm";
+import encode from "hi-base32";
+import { TOTP } from "otpauth";
+import QRCode from "qrcode";
+import { IS_CLOUD } from "../constants";
+
+export type Auth = typeof auth.$inferSelect;
+
+export const createAdmin = async (input: typeof apiCreateAdmin._type) => {
+	return await db.transaction(async (tx) => {
+		const hashedPassword = bcrypt.hashSync(input.password, 10);
+		const newAuth = await tx
+			.insert(auth)
+			.values({
+				email: input.email,
+				password: hashedPassword,
+				rol: "admin",
+			})
+			.returning()
+			.then((res) => res[0]);
+
+		if (!newAuth) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: "Error to create the user",
+			});
+		}
+
+		await tx
+			.insert(admins)
+			.values({
+				authId: newAuth.id,
+				...(!IS_CLOUD && {
+					serverIp: await getPublicIpWithFallback(),
+				}),
+				serverIp: await getPublicIpWithFallback(),
+			})
+			.returning();
+
+		return newAuth;
+	});
+};
+
+export const createUser = async (input: typeof apiCreateUser._type) => {
+	return await db.transaction(async (tx) => {
+		const hashedPassword = bcrypt.hashSync(input.password, 10);
+		const res = await tx
+			.update(auth)
+			.set({
+				password: hashedPassword,
+			})
+			.where(eq(auth.id, input.id))
+			.returning()
+			.then((res) => res[0]);
+
+		if (!res) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: "Error to create the user",
+			});
+		}
+
+		const user = await tx
+			.update(users)
+			.set({
+				isRegistered: true,
+				expirationDate: undefined,
+			})
+			.where(eq(users.token, input.token))
+			.returning()
+			.then((res) => res[0]);
+
+		return user;
+	});
+};
+
+export const findAuthByEmail = async (email: string) => {
+	const result = await db.query.auth.findFirst({
+		where: eq(auth.email, email),
+	});
+	if (!result) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Auth not found",
+		});
+	}
+	return result;
+};
+
+export const findAuthById = async (authId: string) => {
+	const result = await db.query.auth.findFirst({
+		where: eq(auth.id, authId),
+		columns: {
+			password: false,
+		},
+	});
+	if (!result) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Auth not found",
+		});
+	}
+	return result;
+};
+
+export const updateAuthById = async (
+	authId: string,
+	authData: Partial<Auth>,
+) => {
+	const result = await db
+		.update(auth)
+		.set({
+			...authData,
+		})
+		.where(eq(auth.id, authId))
+		.returning();
+
+	return result[0];
+};
+
+export const generate2FASecret = async (authId: string) => {
+	const auth = await findAuthById(authId);
+
+	const base32_secret = generateBase32Secret();
+
+	const totp = new TOTP({
+		issuer: "Dokploy",
+		label: `${auth?.email}`,
+		algorithm: "SHA1",
+		digits: 6,
+		secret: base32_secret,
+	});
+
+	const otpauth_url = totp.toString();
+
+	const qrUrl = await QRCode.toDataURL(otpauth_url);
+
+	return {
+		qrCodeUrl: qrUrl,
+		secret: base32_secret,
+	};
+};
+
+export const verify2FA = async (
+	auth: Omit<Auth, "password">,
+	secret: string,
+	pin: string,
+) => {
+	const totp = new TOTP({
+		issuer: "Dokploy",
+		label: `${auth?.email}`,
+		algorithm: "SHA1",
+		digits: 6,
+		secret: secret,
+	});
+
+	const delta = totp.validate({ token: pin });
+
+	if (delta === null) {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Invalid 2FA code",
+		});
+	}
+	return auth;
+};
+
+const generateBase32Secret = () => {
+	const buffer = randomBytes(15);
+	const base32 = encode.encode(buffer).replace(/=/g, "").substring(0, 24);
+	return base32;
+};

packages/server/src/services/backup.ts

@@ -0,0 +1,71 @@
+import { db } from "@/server/db";
+import { type apiCreateBackup, backups } from "@/server/db/schema";
+import { TRPCError } from "@trpc/server";
+import { eq } from "drizzle-orm";
+
+export type Backup = typeof backups.$inferSelect;
+
+export type BackupSchedule = Awaited<ReturnType<typeof findBackupById>>;
+
+export const createBackup = async (input: typeof apiCreateBackup._type) => {
+	const newBackup = await db
+		.insert(backups)
+		.values({
+			...input,
+		})
+		.returning()
+		.then((value) => value[0]);
+
+	if (!newBackup) {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Error to create the Backup",
+		});
+	}
+
+	return newBackup;
+};
+
+export const findBackupById = async (backupId: string) => {
+	const backup = await db.query.backups.findFirst({
+		where: eq(backups.backupId, backupId),
+		with: {
+			postgres: true,
+			mysql: true,
+			mariadb: true,
+			mongo: true,
+			destination: true,
+		},
+	});
+	if (!backup) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Backup not found",
+		});
+	}
+	return backup;
+};
+
+export const updateBackupById = async (
+	backupId: string,
+	backupData: Partial<Backup>,
+) => {
+	const result = await db
+		.update(backups)
+		.set({
+			...backupData,
+		})
+		.where(eq(backups.backupId, backupId))
+		.returning();
+
+	return result[0];
+};
+
+export const removeBackupById = async (backupId: string) => {
+	const result = await db
+		.delete(backups)
+		.where(eq(backups.backupId, backupId))
+		.returning();
+
+	return result[0];
+};

packages/server/src/services/bitbucket.ts

@@ -0,0 +1,90 @@
+import { db } from "@/server/db";
+import {
+	type apiCreateBitbucket,
+	type apiUpdateBitbucket,
+	bitbucket,
+	gitProvider,
+} from "@/server/db/schema";
+import { TRPCError } from "@trpc/server";
+import { eq } from "drizzle-orm";
+
+export type Bitbucket = typeof bitbucket.$inferSelect;
+
+export const createBitbucket = async (
+	input: typeof apiCreateBitbucket._type,
+	adminId: string,
+) => {
+	return await db.transaction(async (tx) => {
+		const newGitProvider = await tx
+			.insert(gitProvider)
+			.values({
+				providerType: "bitbucket",
+				adminId: adminId,
+				name: input.name,
+			})
+			.returning()
+			.then((response) => response[0]);
+
+		if (!newGitProvider) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: "Error to create the git provider",
+			});
+		}
+
+		await tx
+			.insert(bitbucket)
+			.values({
+				...input,
+				gitProviderId: newGitProvider?.gitProviderId,
+			})
+			.returning()
+			.then((response) => response[0]);
+	});
+};
+
+export const findBitbucketById = async (bitbucketId: string) => {
+	const bitbucketProviderResult = await db.query.bitbucket.findFirst({
+		where: eq(bitbucket.bitbucketId, bitbucketId),
+		with: {
+			gitProvider: true,
+		},
+	});
+
+	if (!bitbucketProviderResult) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Bitbucket Provider not found",
+		});
+	}
+
+	return bitbucketProviderResult;
+};
+
+export const updateBitbucket = async (
+	bitbucketId: string,
+	input: typeof apiUpdateBitbucket._type,
+) => {
+	return await db.transaction(async (tx) => {
+		const result = await tx
+			.update(bitbucket)
+			.set({
+				...input,
+			})
+			.where(eq(bitbucket.bitbucketId, bitbucketId))
+			.returning();
+
+		if (input.name || input.adminId) {
+			await tx
+				.update(gitProvider)
+				.set({
+					name: input.name,
+					adminId: input.adminId,
+				})
+				.where(eq(gitProvider.gitProviderId, input.gitProviderId))
+				.returning();
+		}
+
+		return result[0];
+	});
+};

packages/server/src/services/certificate.ts

@@ -0,0 +1,108 @@
+import fs from "node:fs";
+import path from "node:path";
+import { paths } from "@/server/constants";
+import { db } from "@/server/db";
+import { type apiCreateCertificate, certificates } from "@/server/db/schema";
+import { removeDirectoryIfExistsContent } from "@/server/utils/filesystem/directory";
+import { TRPCError } from "@trpc/server";
+import { eq } from "drizzle-orm";
+import { dump } from "js-yaml";
+import type { z } from "zod";
+
+export type Certificate = typeof certificates.$inferSelect;
+
+export const findCertificateById = async (certificateId: string) => {
+	const certificate = await db.query.certificates.findFirst({
+		where: eq(certificates.certificateId, certificateId),
+	});
+
+	if (!certificate) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Certificate not found",
+		});
+	}
+
+	return certificate;
+};
+
+export const createCertificate = async (
+	certificateData: z.infer<typeof apiCreateCertificate>,
+) => {
+	const certificate = await db
+		.insert(certificates)
+		.values({
+			...certificateData,
+		})
+		.returning();
+
+	if (!certificate || certificate[0] === undefined) {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Failed to create the certificate",
+		});
+	}
+
+	const cer = certificate[0];
+
+	createCertificateFiles(cer);
+	return cer;
+};
+
+export const removeCertificateById = async (certificateId: string) => {
+	const { CERTIFICATES_PATH } = paths();
+	const certificate = await findCertificateById(certificateId);
+	const certDir = path.join(CERTIFICATES_PATH, certificate.certificatePath);
+
+	await removeDirectoryIfExistsContent(certDir);
+	const result = await db
+		.delete(certificates)
+		.where(eq(certificates.certificateId, certificateId))
+		.returning();
+
+	if (!result) {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Failed to delete the certificate",
+		});
+	}
+
+	return result;
+};
+
+export const findCertificates = async () => {
+	return await db.query.certificates.findMany();
+};
+
+const createCertificateFiles = (certificate: Certificate) => {
+	const { CERTIFICATES_PATH } = paths();
+	const dockerPath = "/etc/traefik";
+	const certDir = path.join(CERTIFICATES_PATH, certificate.certificatePath);
+	const crtPath = path.join(certDir, "chain.crt");
+	const keyPath = path.join(certDir, "privkey.key");
+
+	const chainPath = path.join(dockerPath, certDir, "chain.crt");
+	const keyPathDocker = path.join(dockerPath, certDir, "privkey.key");
+
+	if (!fs.existsSync(certDir)) {
+		fs.mkdirSync(certDir, { recursive: true });
+	}
+
+	fs.writeFileSync(crtPath, certificate.certificateData);
+	fs.writeFileSync(keyPath, certificate.privateKey);
+
+	const traefikConfig = {
+		tls: {
+			certificates: [
+				{
+					certFile: chainPath,
+					keyFile: keyPathDocker,
+				},
+			],
+		},
+	};
+
+	const yamlConfig = dump(traefikConfig);
+	const configFile = path.join(certDir, "certificate.yml");
+	fs.writeFileSync(configFile, yamlConfig);
+};

packages/server/src/services/cluster.ts

@@ -0,0 +1,41 @@
+export interface DockerNode {
+	ID: string;
+	Version: {
+		Index: number;
+	};
+	CreatedAt: string;
+	UpdatedAt: string;
+	Spec: {
+		Name: string;
+		Labels: Record<string, string>;
+		Role: "worker" | "manager";
+		Availability: "active" | "pause" | "drain";
+	};
+	Description: {
+		Hostname: string;
+		Platform: {
+			Architecture: string;
+			OS: string;
+		};
+		Resources: {
+			NanoCPUs: number;
+			MemoryBytes: number;
+		};
+		Engine: {
+			EngineVersion: string;
+			Plugins: Array<{
+				Type: string;
+				Name: string;
+			}>;
+		};
+	};
+	Status: {
+		State: "unknown" | "down" | "ready" | "disconnected";
+		Message: string;
+		Addr: string;
+	};
+	ManagerStatus?: {
+		Leader: boolean;
+		Addr: string;
+	};
+}

packages/server/src/services/compose.ts

@@ -0,0 +1,467 @@
+import { join } from "node:path";
+import { paths } from "@/server/constants";
+import { db } from "@/server/db";
+import { type apiCreateCompose, compose } from "@/server/db/schema";
+import { generateAppName } from "@/server/db/schema";
+import { generatePassword } from "@/server/templates/utils";
+import {
+	buildCompose,
+	getBuildComposeCommand,
+} from "@/server/utils/builders/compose";
+import { randomizeSpecificationFile } from "@/server/utils/docker/compose";
+import {
+	cloneCompose,
+	cloneComposeRemote,
+	loadDockerCompose,
+	loadDockerComposeRemote,
+} from "@/server/utils/docker/domain";
+import type { ComposeSpecification } from "@/server/utils/docker/types";
+import { sendBuildErrorNotifications } from "@/server/utils/notifications/build-error";
+import { sendBuildSuccessNotifications } from "@/server/utils/notifications/build-success";
+import { execAsync, execAsyncRemote } from "@/server/utils/process/execAsync";
+import {
+	cloneBitbucketRepository,
+	getBitbucketCloneCommand,
+} from "@/server/utils/providers/bitbucket";
+import {
+	cloneGitRepository,
+	getCustomGitCloneCommand,
+} from "@/server/utils/providers/git";
+import {
+	cloneGithubRepository,
+	getGithubCloneCommand,
+} from "@/server/utils/providers/github";
+import {
+	cloneGitlabRepository,
+	getGitlabCloneCommand,
+} from "@/server/utils/providers/gitlab";
+import {
+	createComposeFile,
+	getCreateComposeFileCommand,
+} from "@/server/utils/providers/raw";
+import { TRPCError } from "@trpc/server";
+import { eq } from "drizzle-orm";
+import { getDokployUrl } from "./admin";
+import { createDeploymentCompose, updateDeploymentStatus } from "./deployment";
+import { validUniqueServerAppName } from "./project";
+
+export type Compose = typeof compose.$inferSelect;
+
+export const createCompose = async (input: typeof apiCreateCompose._type) => {
+	input.appName =
+		`${input.appName}-${generatePassword(6)}` || generateAppName("compose");
+	if (input.appName) {
+		const valid = await validUniqueServerAppName(input.appName);
+
+		if (!valid) {
+			throw new TRPCError({
+				code: "CONFLICT",
+				message: "Service with this 'AppName' already exists",
+			});
+		}
+	}
+
+	const newDestination = await db
+		.insert(compose)
+		.values({
+			...input,
+			composeFile: "",
+		})
+		.returning()
+		.then((value) => value[0]);
+
+	if (!newDestination) {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Error input: Inserting compose",
+		});
+	}
+
+	return newDestination;
+};
+
+export const createComposeByTemplate = async (
+	input: typeof compose.$inferInsert,
+) => {
+	if (input.appName) {
+		const valid = await validUniqueServerAppName(input.appName);
+
+		if (!valid) {
+			throw new TRPCError({
+				code: "CONFLICT",
+				message: "Service with this 'AppName' already exists",
+			});
+		}
+	}
+	const newDestination = await db
+		.insert(compose)
+		.values({
+			...input,
+		})
+		.returning()
+		.then((value) => value[0]);
+
+	if (!newDestination) {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Error input: Inserting compose",
+		});
+	}
+
+	return newDestination;
+};
+
+export const findComposeById = async (composeId: string) => {
+	const result = await db.query.compose.findFirst({
+		where: eq(compose.composeId, composeId),
+		with: {
+			project: true,
+			deployments: true,
+			mounts: true,
+			domains: true,
+			github: true,
+			gitlab: true,
+			bitbucket: true,
+			server: true,
+		},
+	});
+	if (!result) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Compose not found",
+		});
+	}
+	return result;
+};
+
+export const loadServices = async (
+	composeId: string,
+	type: "fetch" | "cache" = "fetch",
+) => {
+	const compose = await findComposeById(composeId);
+
+	if (type === "fetch") {
+		if (compose.serverId) {
+			await cloneComposeRemote(compose);
+		} else {
+			await cloneCompose(compose);
+		}
+	}
+
+	let composeData: ComposeSpecification | null;
+
+	if (compose.serverId) {
+		composeData = await loadDockerComposeRemote(compose);
+	} else {
+		composeData = await loadDockerCompose(compose);
+	}
+
+	if (compose.randomize && composeData) {
+		const randomizedCompose = randomizeSpecificationFile(
+			composeData,
+			compose.suffix,
+		);
+		composeData = randomizedCompose;
+	}
+
+	if (!composeData?.services) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Services not found",
+		});
+	}
+
+	const services = Object.keys(composeData.services);
+
+	return [...services];
+};
+
+export const updateCompose = async (
+	composeId: string,
+	composeData: Partial<Compose>,
+) => {
+	const composeResult = await db
+		.update(compose)
+		.set({
+			...composeData,
+		})
+		.where(eq(compose.composeId, composeId))
+		.returning();
+
+	return composeResult[0];
+};
+
+export const deployCompose = async ({
+	composeId,
+	titleLog = "Manual deployment",
+	descriptionLog = "",
+}: {
+	composeId: string;
+	titleLog: string;
+	descriptionLog: string;
+}) => {
+	const compose = await findComposeById(composeId);
+	const buildLink = `${await getDokployUrl()}/dashboard/project/${compose.projectId}/services/compose/${compose.composeId}?tab=deployments`;
+	const deployment = await createDeploymentCompose({
+		composeId: composeId,
+		title: titleLog,
+		description: descriptionLog,
+	});
+
+	try {
+		if (compose.sourceType === "github") {
+			await cloneGithubRepository(compose, deployment.logPath, true);
+		} else if (compose.sourceType === "gitlab") {
+			await cloneGitlabRepository(compose, deployment.logPath, true);
+		} else if (compose.sourceType === "bitbucket") {
+			await cloneBitbucketRepository(compose, deployment.logPath, true);
+		} else if (compose.sourceType === "git") {
+			await cloneGitRepository(compose, deployment.logPath, true);
+		} else if (compose.sourceType === "raw") {
+			await createComposeFile(compose, deployment.logPath);
+		}
+		await buildCompose(compose, deployment.logPath);
+		await updateDeploymentStatus(deployment.deploymentId, "done");
+		await updateCompose(composeId, {
+			composeStatus: "done",
+		});
+
+		await sendBuildSuccessNotifications({
+			projectName: compose.project.name,
+			applicationName: compose.name,
+			applicationType: "compose",
+			buildLink,
+		});
+	} catch (error) {
+		await updateDeploymentStatus(deployment.deploymentId, "error");
+		await updateCompose(composeId, {
+			composeStatus: "error",
+		});
+		await sendBuildErrorNotifications({
+			projectName: compose.project.name,
+			applicationName: compose.name,
+			applicationType: "compose",
+			// @ts-ignore
+			errorMessage: error?.message || "Error to build",
+			buildLink,
+		});
+		throw error;
+	}
+};
+
+export const rebuildCompose = async ({
+	composeId,
+	titleLog = "Rebuild deployment",
+	descriptionLog = "",
+}: {
+	composeId: string;
+	titleLog: string;
+	descriptionLog: string;
+}) => {
+	const compose = await findComposeById(composeId);
+	const deployment = await createDeploymentCompose({
+		composeId: composeId,
+		title: titleLog,
+		description: descriptionLog,
+	});
+
+	try {
+		if (compose.serverId) {
+			await getBuildComposeCommand(compose, deployment.logPath);
+		} else {
+			await buildCompose(compose, deployment.logPath);
+		}
+
+		await updateDeploymentStatus(deployment.deploymentId, "done");
+		await updateCompose(composeId, {
+			composeStatus: "done",
+		});
+	} catch (error) {
+		await updateDeploymentStatus(deployment.deploymentId, "error");
+		await updateCompose(composeId, {
+			composeStatus: "error",
+		});
+		throw error;
+	}
+
+	return true;
+};
+
+export const deployRemoteCompose = async ({
+	composeId,
+	titleLog = "Manual deployment",
+	descriptionLog = "",
+}: {
+	composeId: string;
+	titleLog: string;
+	descriptionLog: string;
+}) => {
+	const compose = await findComposeById(composeId);
+	const buildLink = `${await getDokployUrl()}/dashboard/project/${compose.projectId}/services/compose/${compose.composeId}?tab=deployments`;
+	const deployment = await createDeploymentCompose({
+		composeId: composeId,
+		title: titleLog,
+		description: descriptionLog,
+	});
+	try {
+		if (compose.serverId) {
+			let command = "set -e;";
+
+			if (compose.sourceType === "github") {
+				command += await getGithubCloneCommand(
+					compose,
+					deployment.logPath,
+					true,
+				);
+			} else if (compose.sourceType === "gitlab") {
+				command += await getGitlabCloneCommand(
+					compose,
+					deployment.logPath,
+					true,
+				);
+			} else if (compose.sourceType === "bitbucket") {
+				command += await getBitbucketCloneCommand(
+					compose,
+					deployment.logPath,
+					true,
+				);
+			} else if (compose.sourceType === "git") {
+				command += await getCustomGitCloneCommand(
+					compose,
+					deployment.logPath,
+					true,
+				);
+			} else if (compose.sourceType === "raw") {
+				command += getCreateComposeFileCommand(compose, deployment.logPath);
+			}
+
+			await execAsyncRemote(compose.serverId, command);
+			await getBuildComposeCommand(compose, deployment.logPath);
+		}
+
+		await updateDeploymentStatus(deployment.deploymentId, "done");
+		await updateCompose(composeId, {
+			composeStatus: "done",
+		});
+
+		await sendBuildSuccessNotifications({
+			projectName: compose.project.name,
+			applicationName: compose.name,
+			applicationType: "compose",
+			buildLink,
+		});
+	} catch (error) {
+		console.log(error);
+		await updateDeploymentStatus(deployment.deploymentId, "error");
+		await updateCompose(composeId, {
+			composeStatus: "error",
+		});
+		await sendBuildErrorNotifications({
+			projectName: compose.project.name,
+			applicationName: compose.name,
+			applicationType: "compose",
+			// @ts-ignore
+			errorMessage: error?.message || "Error to build",
+			buildLink,
+		});
+		throw error;
+	}
+};
+
+export const rebuildRemoteCompose = async ({
+	composeId,
+	titleLog = "Rebuild deployment",
+	descriptionLog = "",
+}: {
+	composeId: string;
+	titleLog: string;
+	descriptionLog: string;
+}) => {
+	const compose = await findComposeById(composeId);
+	const deployment = await createDeploymentCompose({
+		composeId: composeId,
+		title: titleLog,
+		description: descriptionLog,
+	});
+
+	try {
+		if (compose.serverId) {
+			await getBuildComposeCommand(compose, deployment.logPath);
+		}
+
+		await updateDeploymentStatus(deployment.deploymentId, "done");
+		await updateCompose(composeId, {
+			composeStatus: "done",
+		});
+	} catch (error) {
+		await updateDeploymentStatus(deployment.deploymentId, "error");
+		await updateCompose(composeId, {
+			composeStatus: "error",
+		});
+		throw error;
+	}
+
+	return true;
+};
+
+export const removeCompose = async (compose: Compose) => {
+	try {
+		const { COMPOSE_PATH } = paths(!!compose.serverId);
+		const projectPath = join(COMPOSE_PATH, compose.appName);
+
+		if (compose.composeType === "stack") {
+			const command = `cd ${projectPath} && docker stack rm ${compose.appName} && rm -rf ${projectPath}`;
+			if (compose.serverId) {
+				await execAsyncRemote(compose.serverId, command);
+			} else {
+				await execAsync(command);
+			}
+			await execAsync(command, {
+				cwd: projectPath,
+			});
+		} else {
+			const command = `cd ${projectPath} && docker compose -p ${compose.appName} down && rm -rf ${projectPath}`;
+			if (compose.serverId) {
+				await execAsyncRemote(compose.serverId, command);
+			} else {
+				await execAsync(command, {
+					cwd: projectPath,
+				});
+			}
+		}
+	} catch (error) {
+		throw error;
+	}
+
+	return true;
+};
+
+export const stopCompose = async (composeId: string) => {
+	const compose = await findComposeById(composeId);
+	try {
+		const { COMPOSE_PATH } = paths(!!compose.serverId);
+		if (compose.composeType === "docker-compose") {
+			if (compose.serverId) {
+				await execAsyncRemote(
+					compose.serverId,
+					`cd ${join(COMPOSE_PATH, compose.appName)} && docker compose -p ${compose.appName} stop`,
+				);
+			} else {
+				await execAsync(`docker compose -p ${compose.appName} stop`, {
+					cwd: join(COMPOSE_PATH, compose.appName),
+				});
+			}
+		}
+
+		await updateCompose(composeId, {
+			composeStatus: "idle",
+		});
+	} catch (error) {
+		await updateCompose(composeId, {
+			composeStatus: "error",
+		});
+		throw error;
+	}
+
+	return true;
+};

packages/server/src/services/deployment.ts

@@ -0,0 +1,372 @@
+import { existsSync, promises as fsPromises } from "node:fs";
+import path from "node:path";
+import { paths } from "@/server/constants";
+import { db } from "@/server/db";
+import {
+	type apiCreateDeployment,
+	type apiCreateDeploymentCompose,
+	type apiCreateDeploymentServer,
+	deployments,
+} from "@/server/db/schema";
+import { removeDirectoryIfExistsContent } from "@/server/utils/filesystem/directory";
+import { TRPCError } from "@trpc/server";
+import { format } from "date-fns";
+import { desc, eq } from "drizzle-orm";
+import {
+	type Application,
+	findApplicationById,
+	updateApplicationStatus,
+} from "./application";
+import { type Compose, findComposeById, updateCompose } from "./compose";
+import { type Server, findServerById } from "./server";
+
+import { execAsyncRemote } from "@/server/utils/process/execAsync";
+
+export type Deployment = typeof deployments.$inferSelect;
+
+export const findDeploymentById = async (applicationId: string) => {
+	const application = await db.query.deployments.findFirst({
+		where: eq(deployments.applicationId, applicationId),
+		with: {
+			application: true,
+		},
+	});
+	if (!application) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Deployment not found",
+		});
+	}
+	return application;
+};
+
+export const createDeployment = async (
+	deployment: Omit<
+		typeof apiCreateDeployment._type,
+		"deploymentId" | "createdAt" | "status" | "logPath"
+	>,
+) => {
+	const application = await findApplicationById(deployment.applicationId);
+
+	try {
+		// await removeLastTenDeployments(deployment.applicationId);
+		const { LOGS_PATH } = paths(!!application.serverId);
+		const formattedDateTime = format(new Date(), "yyyy-MM-dd:HH:mm:ss");
+		const fileName = `${application.appName}-${formattedDateTime}.log`;
+		const logFilePath = path.join(LOGS_PATH, application.appName, fileName);
+
+		if (application.serverId) {
+			const server = await findServerById(application.serverId);
+
+			const command = `
+				mkdir -p ${LOGS_PATH}/${application.appName};
+            	echo "Initializing deployment" >> ${logFilePath};
+			`;
+
+			await execAsyncRemote(server.serverId, command);
+		} else {
+			await fsPromises.mkdir(path.join(LOGS_PATH, application.appName), {
+				recursive: true,
+			});
+			await fsPromises.writeFile(logFilePath, "Initializing deployment");
+		}
+
+		const deploymentCreate = await db
+			.insert(deployments)
+			.values({
+				applicationId: deployment.applicationId,
+				title: deployment.title || "Deployment",
+				status: "running",
+				logPath: logFilePath,
+				description: deployment.description || "",
+			})
+			.returning();
+		if (deploymentCreate.length === 0 || !deploymentCreate[0]) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: "Error to create the deployment",
+			});
+		}
+		return deploymentCreate[0];
+	} catch (error) {
+		await updateApplicationStatus(application.applicationId, "error");
+		console.log(error);
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Error to create the deployment",
+		});
+	}
+};
+
+export const createDeploymentCompose = async (
+	deployment: Omit<
+		typeof apiCreateDeploymentCompose._type,
+		"deploymentId" | "createdAt" | "status" | "logPath"
+	>,
+) => {
+	const compose = await findComposeById(deployment.composeId);
+	try {
+		// await removeLastTenComposeDeployments(deployment.composeId);
+		const { LOGS_PATH } = paths(!!compose.serverId);
+		const formattedDateTime = format(new Date(), "yyyy-MM-dd:HH:mm:ss");
+		const fileName = `${compose.appName}-${formattedDateTime}.log`;
+		const logFilePath = path.join(LOGS_PATH, compose.appName, fileName);
+
+		if (compose.serverId) {
+			const server = await findServerById(compose.serverId);
+
+			const command = `
+mkdir -p ${LOGS_PATH}/${compose.appName};
+echo "Initializing deployment" >> ${logFilePath};
+`;
+
+			await execAsyncRemote(server.serverId, command);
+		} else {
+			await fsPromises.mkdir(path.join(LOGS_PATH, compose.appName), {
+				recursive: true,
+			});
+			await fsPromises.writeFile(logFilePath, "Initializing deployment");
+		}
+
+		const deploymentCreate = await db
+			.insert(deployments)
+			.values({
+				composeId: deployment.composeId,
+				title: deployment.title || "Deployment",
+				description: deployment.description || "",
+				status: "running",
+				logPath: logFilePath,
+			})
+			.returning();
+		if (deploymentCreate.length === 0 || !deploymentCreate[0]) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: "Error to create the deployment",
+			});
+		}
+		return deploymentCreate[0];
+	} catch (error) {
+		await updateCompose(compose.composeId, {
+			composeStatus: "error",
+		});
+		console.log(error);
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Error to create the deployment",
+		});
+	}
+};
+
+export const removeDeployment = async (deploymentId: string) => {
+	try {
+		const deployment = await db
+			.delete(deployments)
+			.where(eq(deployments.deploymentId, deploymentId))
+			.returning();
+		return deployment[0];
+	} catch (error) {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Error to delete this deployment",
+		});
+	}
+};
+
+export const removeDeploymentsByApplicationId = async (
+	applicationId: string,
+) => {
+	await db
+		.delete(deployments)
+		.where(eq(deployments.applicationId, applicationId))
+		.returning();
+};
+
+const removeLastTenDeployments = async (applicationId: string) => {
+	const deploymentList = await db.query.deployments.findMany({
+		where: eq(deployments.applicationId, applicationId),
+		orderBy: desc(deployments.createdAt),
+	});
+	if (deploymentList.length > 10) {
+		const deploymentsToDelete = deploymentList.slice(10);
+		for (const oldDeployment of deploymentsToDelete) {
+			const logPath = path.join(oldDeployment.logPath);
+			if (existsSync(logPath)) {
+				await fsPromises.unlink(logPath);
+			}
+			await removeDeployment(oldDeployment.deploymentId);
+		}
+	}
+};
+
+const removeLastTenComposeDeployments = async (composeId: string) => {
+	const deploymentList = await db.query.deployments.findMany({
+		where: eq(deployments.composeId, composeId),
+		orderBy: desc(deployments.createdAt),
+	});
+	if (deploymentList.length > 10) {
+		const deploymentsToDelete = deploymentList.slice(10);
+		for (const oldDeployment of deploymentsToDelete) {
+			const logPath = path.join(oldDeployment.logPath);
+			if (existsSync(logPath)) {
+				await fsPromises.unlink(logPath);
+			}
+			await removeDeployment(oldDeployment.deploymentId);
+		}
+	}
+};
+
+export const removeDeployments = async (application: Application) => {
+	const { appName, applicationId } = application;
+	const { LOGS_PATH } = paths(!!application.serverId);
+	const logsPath = path.join(LOGS_PATH, appName);
+	if (application.serverId) {
+		await execAsyncRemote(application.serverId, `rm -rf ${logsPath}`);
+	} else {
+		await removeDirectoryIfExistsContent(logsPath);
+	}
+	await removeDeploymentsByApplicationId(applicationId);
+};
+
+export const removeDeploymentsByComposeId = async (compose: Compose) => {
+	const { appName } = compose;
+	const { LOGS_PATH } = paths(!!compose.serverId);
+	const logsPath = path.join(LOGS_PATH, appName);
+	if (compose.serverId) {
+		await execAsyncRemote(compose.serverId, `rm -rf ${logsPath}`);
+	} else {
+		await removeDirectoryIfExistsContent(logsPath);
+	}
+
+	await db
+		.delete(deployments)
+		.where(eq(deployments.composeId, compose.composeId))
+		.returning();
+};
+
+export const findAllDeploymentsByApplicationId = async (
+	applicationId: string,
+) => {
+	const deploymentsList = await db.query.deployments.findMany({
+		where: eq(deployments.applicationId, applicationId),
+		orderBy: desc(deployments.createdAt),
+	});
+	return deploymentsList;
+};
+
+export const findAllDeploymentsByComposeId = async (composeId: string) => {
+	const deploymentsList = await db.query.deployments.findMany({
+		where: eq(deployments.composeId, composeId),
+		orderBy: desc(deployments.createdAt),
+	});
+	return deploymentsList;
+};
+
+export const updateDeployment = async (
+	deploymentId: string,
+	deploymentData: Partial<Deployment>,
+) => {
+	const application = await db
+		.update(deployments)
+		.set({
+			...deploymentData,
+		})
+		.where(eq(deployments.deploymentId, deploymentId))
+		.returning();
+
+	return application;
+};
+
+export const updateDeploymentStatus = async (
+	deploymentId: string,
+	deploymentStatus: Deployment["status"],
+) => {
+	const application = await db
+		.update(deployments)
+		.set({
+			status: deploymentStatus,
+		})
+		.where(eq(deployments.deploymentId, deploymentId))
+		.returning();
+
+	return application;
+};
+
+export const createServerDeployment = async (
+	deployment: Omit<
+		typeof apiCreateDeploymentServer._type,
+		"deploymentId" | "createdAt" | "status" | "logPath"
+	>,
+) => {
+	try {
+		const { LOGS_PATH } = paths();
+
+		const server = await findServerById(deployment.serverId);
+		await removeLastFiveDeployments(deployment.serverId);
+		const formattedDateTime = format(new Date(), "yyyy-MM-dd:HH:mm:ss");
+		const fileName = `${server.appName}-${formattedDateTime}.log`;
+		const logFilePath = path.join(LOGS_PATH, server.appName, fileName);
+		await fsPromises.mkdir(path.join(LOGS_PATH, server.appName), {
+			recursive: true,
+		});
+		await fsPromises.writeFile(logFilePath, "Initializing Setup Server");
+		const deploymentCreate = await db
+			.insert(deployments)
+			.values({
+				serverId: server.serverId,
+				title: deployment.title || "Deployment",
+				description: deployment.description || "",
+				status: "running",
+				logPath: logFilePath,
+			})
+			.returning();
+		if (deploymentCreate.length === 0 || !deploymentCreate[0]) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: "Error to create the deployment",
+			});
+		}
+		return deploymentCreate[0];
+	} catch (error) {
+		console.log(error);
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Error to create the deployment",
+		});
+	}
+};
+
+export const removeLastFiveDeployments = async (serverId: string) => {
+	const deploymentList = await db.query.deployments.findMany({
+		where: eq(deployments.serverId, serverId),
+		orderBy: desc(deployments.createdAt),
+	});
+	if (deploymentList.length >= 5) {
+		const deploymentsToDelete = deploymentList.slice(4);
+		for (const oldDeployment of deploymentsToDelete) {
+			const logPath = path.join(oldDeployment.logPath);
+			if (existsSync(logPath)) {
+				await fsPromises.unlink(logPath);
+			}
+			await removeDeployment(oldDeployment.deploymentId);
+		}
+	}
+};
+
+export const removeDeploymentsByServerId = async (server: Server) => {
+	const { LOGS_PATH } = paths();
+	const { appName } = server;
+	const logsPath = path.join(LOGS_PATH, appName);
+	await removeDirectoryIfExistsContent(logsPath);
+	await db
+		.delete(deployments)
+		.where(eq(deployments.serverId, server.serverId))
+		.returning();
+};
+
+export const findAllDeploymentsByServerId = async (serverId: string) => {
+	const deploymentsList = await db.query.deployments.findMany({
+		where: eq(deployments.serverId, serverId),
+		orderBy: desc(deployments.createdAt),
+	});
+	return deploymentsList;
+};

packages/server/src/services/destination.ts

@@ -0,0 +1,79 @@
+import { db } from "@/server/db";
+import { type apiCreateDestination, destinations } from "@/server/db/schema";
+import { TRPCError } from "@trpc/server";
+import { and, eq } from "drizzle-orm";
+
+export type Destination = typeof destinations.$inferSelect;
+
+export const createDestintation = async (
+	input: typeof apiCreateDestination._type,
+	adminId: string,
+) => {
+	const newDestination = await db
+		.insert(destinations)
+		.values({
+			...input,
+			adminId: adminId,
+		})
+		.returning()
+		.then((value) => value[0]);
+
+	if (!newDestination) {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Error input: Inserting destination",
+		});
+	}
+
+	return newDestination;
+};
+
+export const findDestinationById = async (destinationId: string) => {
+	const destination = await db.query.destinations.findFirst({
+		where: and(eq(destinations.destinationId, destinationId)),
+	});
+	if (!destination) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Destination not found",
+		});
+	}
+	return destination;
+};
+
+export const removeDestinationById = async (
+	destinationId: string,
+	adminId: string,
+) => {
+	const result = await db
+		.delete(destinations)
+		.where(
+			and(
+				eq(destinations.destinationId, destinationId),
+				eq(destinations.adminId, adminId),
+			),
+		)
+		.returning();
+
+	return result[0];
+};
+
+export const updateDestinationById = async (
+	destinationId: string,
+	destinationData: Partial<Destination>,
+) => {
+	const result = await db
+		.update(destinations)
+		.set({
+			...destinationData,
+		})
+		.where(
+			and(
+				eq(destinations.destinationId, destinationId),
+				eq(destinations.adminId, destinationData.adminId || ""),
+			),
+		)
+		.returning();
+
+	return result[0];
+};

packages/server/src/services/docker.ts

@@ -0,0 +1,223 @@
+import { execAsync, execAsyncRemote } from "@/server/utils/process/execAsync";
+
+export const getContainers = async (serverId?: string | null) => {
+	try {
+		const command =
+			"docker ps -a --format 'CONTAINER ID : {{.ID}} | Name: {{.Names}} | Image: {{.Image}} | Ports: {{.Ports}} | State: {{.State}} | Status: {{.Status}}'";
+		let stdout = "";
+		let stderr = "";
+
+		if (serverId) {
+			const result = await execAsyncRemote(serverId, command);
+
+			stdout = result.stdout;
+			stderr = result.stderr;
+		} else {
+			const result = await execAsync(command);
+			stdout = result.stdout;
+			stderr = result.stderr;
+		}
+		if (stderr) {
+			console.error(`Error: ${stderr}`);
+			return;
+		}
+
+		const lines = stdout.trim().split("\n");
+
+		const containers = lines
+			.map((line) => {
+				const parts = line.split(" | ");
+				const containerId = parts[0]
+					? parts[0].replace("CONTAINER ID : ", "").trim()
+					: "No container id";
+				const name = parts[1]
+					? parts[1].replace("Name: ", "").trim()
+					: "No container name";
+				const image = parts[2]
+					? parts[2].replace("Image: ", "").trim()
+					: "No image";
+				const ports = parts[3]
+					? parts[3].replace("Ports: ", "").trim()
+					: "No ports";
+				const state = parts[4]
+					? parts[4].replace("State: ", "").trim()
+					: "No state";
+				const status = parts[5]
+					? parts[5].replace("Status: ", "").trim()
+					: "No status";
+				return {
+					containerId,
+					name,
+					image,
+					ports,
+					state,
+					status,
+					serverId,
+				};
+			})
+			.filter((container) => !container.name.includes("dokploy"));
+
+		return containers;
+	} catch (error) {
+		console.error(error);
+
+		return [];
+	}
+};
+
+export const getConfig = async (
+	containerId: string,
+	serverId?: string | null,
+) => {
+	try {
+		const command = `docker inspect ${containerId} --format='{{json .}}'`;
+		let stdout = "";
+		let stderr = "";
+		if (serverId) {
+			const result = await execAsyncRemote(serverId, command);
+			stdout = result.stdout;
+			stderr = result.stderr;
+		} else {
+			const result = await execAsync(command);
+			stdout = result.stdout;
+			stderr = result.stderr;
+		}
+
+		if (stderr) {
+			console.error(`Error: ${stderr}`);
+			return;
+		}
+
+		const config = JSON.parse(stdout);
+
+		return config;
+	} catch (error) {}
+};
+
+export const getContainersByAppNameMatch = async (
+	appName: string,
+	appType?: "stack" | "docker-compose",
+	serverId?: string,
+) => {
+	try {
+		let result: string[] = [];
+		const cmd =
+			"docker ps -a --format 'CONTAINER ID : {{.ID}} | Name: {{.Names}} | State: {{.State}}'";
+
+		const command =
+			appType === "docker-compose"
+				? `${cmd} --filter='label=com.docker.compose.project=${appName}'`
+				: `${cmd} | grep ${appName}`;
+		if (serverId) {
+			const { stdout, stderr } = await execAsyncRemote(serverId, command);
+
+			if (stderr) {
+				return [];
+			}
+
+			if (!stdout) return [];
+			result = stdout.trim().split("\n");
+		} else {
+			const { stdout, stderr } = await execAsync(command);
+
+			if (stderr) {
+				return [];
+			}
+
+			if (!stdout) return [];
+
+			result = stdout.trim().split("\n");
+		}
+
+		const containers = result.map((line) => {
+			const parts = line.split(" | ");
+			const containerId = parts[0]
+				? parts[0].replace("CONTAINER ID : ", "").trim()
+				: "No container id";
+			const name = parts[1]
+				? parts[1].replace("Name: ", "").trim()
+				: "No container name";
+
+			const state = parts[2]
+				? parts[2].replace("State: ", "").trim()
+				: "No state";
+			return {
+				containerId,
+				name,
+				state,
+			};
+		});
+
+		return containers || [];
+	} catch (error) {}
+
+	return [];
+};
+
+export const getContainersByAppLabel = async (
+	appName: string,
+	serverId?: string,
+) => {
+	try {
+		let stdout = "";
+		let stderr = "";
+
+		const command = `docker ps --filter "label=com.docker.swarm.service.name=${appName}" --format 'CONTAINER ID : {{.ID}} | Name: {{.Names}} | State: {{.State}}'`;
+		if (serverId) {
+			const result = await execAsyncRemote(serverId, command);
+			stdout = result.stdout;
+			stderr = result.stderr;
+		} else {
+			const result = await execAsync(command);
+			stdout = result.stdout;
+			stderr = result.stderr;
+		}
+		if (stderr) {
+			console.error(`Error: ${stderr}`);
+			return;
+		}
+
+		if (!stdout) return [];
+
+		const lines = stdout.trim().split("\n");
+
+		const containers = lines.map((line) => {
+			const parts = line.split(" | ");
+			const containerId = parts[0]
+				? parts[0].replace("CONTAINER ID : ", "").trim()
+				: "No container id";
+			const name = parts[1]
+				? parts[1].replace("Name: ", "").trim()
+				: "No container name";
+			const state = parts[2]
+				? parts[2].replace("State: ", "").trim()
+				: "No state";
+			return {
+				containerId,
+				name,
+				state,
+			};
+		});
+
+		return containers || [];
+	} catch (error) {}
+
+	return [];
+};
+
+export const containerRestart = async (containerId: string) => {
+	try {
+		const { stdout, stderr } = await execAsync(
+			`docker container restart ${containerId}`,
+		);
+
+		if (stderr) {
+			console.error(`Error: ${stderr}`);
+			return;
+		}
+
+		const config = JSON.parse(stdout);
+
+		return config;
+	} catch (error) {}
+};

packages/server/src/services/domain.ts

@@ -0,0 +1,136 @@
+import { db } from "@/server/db";
+import { generateRandomDomain } from "@/server/templates/utils";
+import { manageDomain } from "@/server/utils/traefik/domain";
+import { TRPCError } from "@trpc/server";
+import { eq } from "drizzle-orm";
+import { type apiCreateDomain, domains } from "../db/schema";
+import { findAdmin, findAdminById } from "./admin";
+import { findApplicationById } from "./application";
+import { findServerById } from "./server";
+
+export type Domain = typeof domains.$inferSelect;
+
+export const createDomain = async (input: typeof apiCreateDomain._type) => {
+	const result = await db.transaction(async (tx) => {
+		const domain = await tx
+			.insert(domains)
+			.values({
+				...input,
+			})
+			.returning()
+			.then((response) => response[0]);
+
+		if (!domain) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: "Error creating domain",
+			});
+		}
+
+		if (domain.applicationId) {
+			const application = await findApplicationById(domain.applicationId);
+			await manageDomain(application, domain);
+		}
+
+		return domain;
+	});
+
+	return result;
+};
+
+export const generateTraefikMeDomain = async (
+	appName: string,
+	adminId: string,
+	serverId?: string,
+) => {
+	if (serverId) {
+		const server = await findServerById(serverId);
+		return generateRandomDomain({
+			serverIp: server.ipAddress,
+			projectName: appName,
+		});
+	}
+
+	if (process.env.NODE_ENV === "development") {
+		return generateRandomDomain({
+			serverIp: "",
+			projectName: appName,
+		});
+	}
+	const admin = await findAdminById(adminId);
+	return generateRandomDomain({
+		serverIp: admin?.serverIp || "",
+		projectName: appName,
+	});
+};
+
+export const generateWildcardDomain = (
+	appName: string,
+	serverDomain: string,
+) => {
+	return `${appName}-${serverDomain}`;
+};
+
+export const findDomainById = async (domainId: string) => {
+	const domain = await db.query.domains.findFirst({
+		where: eq(domains.domainId, domainId),
+		with: {
+			application: true,
+		},
+	});
+	if (!domain) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Domain not found",
+		});
+	}
+	return domain;
+};
+
+export const findDomainsByApplicationId = async (applicationId: string) => {
+	const domainsArray = await db.query.domains.findMany({
+		where: eq(domains.applicationId, applicationId),
+		with: {
+			application: true,
+		},
+	});
+
+	return domainsArray;
+};
+
+export const findDomainsByComposeId = async (composeId: string) => {
+	const domainsArray = await db.query.domains.findMany({
+		where: eq(domains.composeId, composeId),
+		with: {
+			compose: true,
+		},
+	});
+
+	return domainsArray;
+};
+
+export const updateDomainById = async (
+	domainId: string,
+	domainData: Partial<Domain>,
+) => {
+	const domain = await db
+		.update(domains)
+		.set({
+			...domainData,
+		})
+		.where(eq(domains.domainId, domainId))
+		.returning();
+
+	return domain[0];
+};
+
+export const removeDomainById = async (domainId: string) => {
+	await findDomainById(domainId);
+	// TODO: fix order
+	const result = await db
+		.delete(domains)
+		.where(eq(domains.domainId, domainId))
+		.returning();
+
+	return result[0];
+};

packages/server/src/services/git-provider.ts

@@ -0,0 +1,43 @@
+import { db } from "@/server/db";
+import { gitProvider } from "@/server/db/schema";
+import { TRPCError } from "@trpc/server";
+import { eq } from "drizzle-orm";
+
+export type GitProvider = typeof gitProvider.$inferSelect;
+
+export const removeGitProvider = async (gitProviderId: string) => {
+	const result = await db
+		.delete(gitProvider)
+		.where(eq(gitProvider.gitProviderId, gitProviderId))
+		.returning();
+
+	return result[0];
+};
+
+export const findGitProviderById = async (gitProviderId: string) => {
+	const result = await db.query.gitProvider.findFirst({
+		where: eq(gitProvider.gitProviderId, gitProviderId),
+	});
+
+	if (!result) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Git Provider not found",
+		});
+	}
+	return result;
+};
+
+export const updateGitProvider = async (
+	gitProviderId: string,
+	input: Partial<GitProvider>,
+) => {
+	return await db
+		.update(gitProvider)
+		.set({
+			...input,
+		})
+		.where(eq(gitProvider.gitProviderId, gitProviderId))
+		.returning()
+		.then((response) => response[0]);
+};

packages/server/src/services/github.ts

@@ -0,0 +1,70 @@
+import { db } from "@/server/db";
+import { type apiCreateGithub, gitProvider, github } from "@/server/db/schema";
+import { TRPCError } from "@trpc/server";
+import { eq } from "drizzle-orm";
+
+export type Github = typeof github.$inferSelect;
+export const createGithub = async (
+	input: typeof apiCreateGithub._type,
+	adminId: string,
+) => {
+	return await db.transaction(async (tx) => {
+		const newGitProvider = await tx
+			.insert(gitProvider)
+			.values({
+				providerType: "github",
+				adminId: adminId,
+				name: input.name,
+			})
+			.returning()
+			.then((response) => response[0]);
+
+		if (!newGitProvider) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: "Error to create the git provider",
+			});
+		}
+
+		return await tx
+			.insert(github)
+			.values({
+				...input,
+				gitProviderId: newGitProvider?.gitProviderId,
+			})
+			.returning()
+			.then((response) => response[0]);
+	});
+};
+
+export const findGithubById = async (githubId: string) => {
+	const githubProviderResult = await db.query.github.findFirst({
+		where: eq(github.githubId, githubId),
+		with: {
+			gitProvider: true,
+		},
+	});
+
+	if (!githubProviderResult) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Github Provider not found",
+		});
+	}
+
+	return githubProviderResult;
+};
+
+export const updateGithub = async (
+	githubId: string,
+	input: Partial<Github>,
+) => {
+	return await db
+		.update(github)
+		.set({
+			...input,
+		})
+		.where(eq(github.githubId, githubId))
+		.returning()
+		.then((response) => response[0]);
+};

packages/server/src/services/gitlab.ts

@@ -0,0 +1,77 @@
+import { db } from "@/server/db";
+import {
+	type apiCreateGitlab,
+	type bitbucket,
+	gitProvider,
+	type github,
+	gitlab,
+} from "@/server/db/schema";
+import { TRPCError } from "@trpc/server";
+import { eq } from "drizzle-orm";
+
+export type Gitlab = typeof gitlab.$inferSelect;
+
+export const createGitlab = async (
+	input: typeof apiCreateGitlab._type,
+	adminId: string,
+) => {
+	return await db.transaction(async (tx) => {
+		const newGitProvider = await tx
+			.insert(gitProvider)
+			.values({
+				providerType: "gitlab",
+				adminId: adminId,
+				name: input.name,
+			})
+			.returning()
+			.then((response) => response[0]);
+
+		if (!newGitProvider) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: "Error to create the git provider",
+			});
+		}
+
+		await tx
+			.insert(gitlab)
+			.values({
+				...input,
+				gitProviderId: newGitProvider?.gitProviderId,
+			})
+			.returning()
+			.then((response) => response[0]);
+	});
+};
+
+export const findGitlabById = async (gitlabId: string) => {
+	const gitlabProviderResult = await db.query.gitlab.findFirst({
+		where: eq(gitlab.gitlabId, gitlabId),
+		with: {
+			gitProvider: true,
+		},
+	});
+
+	if (!gitlabProviderResult) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Gitlab Provider not found",
+		});
+	}
+
+	return gitlabProviderResult;
+};
+
+export const updateGitlab = async (
+	gitlabId: string,
+	input: Partial<Gitlab>,
+) => {
+	return await db
+		.update(gitlab)
+		.set({
+			...input,
+		})
+		.where(eq(gitlab.gitlabId, gitlabId))
+		.returning()
+		.then((response) => response[0]);
+};

packages/server/src/services/mariadb.ts

@@ -0,0 +1,147 @@
+import { db } from "@/server/db";
+import { type apiCreateMariaDB, backups, mariadb } from "@/server/db/schema";
+import { generateAppName } from "@/server/db/schema";
+import { generatePassword } from "@/server/templates/utils";
+import { buildMariadb } from "@/server/utils/databases/mariadb";
+import { pullImage } from "@/server/utils/docker/utils";
+import { TRPCError } from "@trpc/server";
+import { eq, getTableColumns } from "drizzle-orm";
+import { validUniqueServerAppName } from "./project";
+
+import { execAsyncRemote } from "@/server/utils/process/execAsync";
+
+export type Mariadb = typeof mariadb.$inferSelect;
+
+export const createMariadb = async (input: typeof apiCreateMariaDB._type) => {
+	input.appName =
+		`${input.appName}-${generatePassword(6)}` || generateAppName("mariadb");
+	if (input.appName) {
+		const valid = await validUniqueServerAppName(input.appName);
+
+		if (!valid) {
+			throw new TRPCError({
+				code: "CONFLICT",
+				message: "Service with this 'AppName' already exists",
+			});
+		}
+	}
+
+	const newMariadb = await db
+		.insert(mariadb)
+		.values({
+			...input,
+			databasePassword: input.databasePassword
+				? input.databasePassword
+				: generatePassword(),
+			databaseRootPassword: input.databaseRootPassword
+				? input.databaseRootPassword
+				: generatePassword(),
+		})
+		.returning()
+		.then((value) => value[0]);
+
+	if (!newMariadb) {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Error input: Inserting mariadb database",
+		});
+	}
+
+	return newMariadb;
+};
+
+// https://github.com/drizzle-team/drizzle-orm/discussions/1483#discussioncomment-7523881
+export const findMariadbById = async (mariadbId: string) => {
+	const result = await db.query.mariadb.findFirst({
+		where: eq(mariadb.mariadbId, mariadbId),
+		with: {
+			project: true,
+			mounts: true,
+			server: true,
+			backups: {
+				with: {
+					destination: true,
+				},
+			},
+		},
+	});
+	if (!result) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Mariadb not found",
+		});
+	}
+	return result;
+};
+
+export const updateMariadbById = async (
+	mariadbId: string,
+	mariadbData: Partial<Mariadb>,
+) => {
+	const result = await db
+		.update(mariadb)
+		.set({
+			...mariadbData,
+		})
+		.where(eq(mariadb.mariadbId, mariadbId))
+		.returning();
+
+	return result[0];
+};
+
+export const removeMariadbById = async (mariadbId: string) => {
+	const result = await db
+		.delete(mariadb)
+		.where(eq(mariadb.mariadbId, mariadbId))
+		.returning();
+
+	return result[0];
+};
+
+export const findMariadbByBackupId = async (backupId: string) => {
+	const result = await db
+		.select({
+			...getTableColumns(mariadb),
+		})
+		.from(mariadb)
+		.innerJoin(backups, eq(mariadb.mariadbId, backups.mariadbId))
+		.where(eq(backups.backupId, backupId))
+		.limit(1);
+
+	if (!result || !result[0]) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "MariaDB not found",
+		});
+	}
+	return result[0];
+};
+
+export const deployMariadb = async (mariadbId: string) => {
+	const mariadb = await findMariadbById(mariadbId);
+	try {
+		if (mariadb.serverId) {
+			await execAsyncRemote(
+				mariadb.serverId,
+				`docker pull ${mariadb.dockerImage}`,
+			);
+		} else {
+			await pullImage(mariadb.dockerImage);
+		}
+
+		await buildMariadb(mariadb);
+		await updateMariadbById(mariadbId, {
+			applicationStatus: "done",
+		});
+	} catch (error) {
+		await updateMariadbById(mariadbId, {
+			applicationStatus: "error",
+		});
+
+		throw new TRPCError({
+			code: "INTERNAL_SERVER_ERROR",
+			message: `Error on deploy mariadb${error}`,
+		});
+	}
+	return mariadb;
+};

packages/server/src/services/mongo.ts

@@ -0,0 +1,140 @@
+import { db } from "@/server/db";
+import { type apiCreateMongo, backups, mongo } from "@/server/db/schema";
+import { generateAppName } from "@/server/db/schema";
+import { generatePassword } from "@/server/templates/utils";
+import { buildMongo } from "@/server/utils/databases/mongo";
+import { pullImage } from "@/server/utils/docker/utils";
+import { TRPCError } from "@trpc/server";
+import { eq, getTableColumns } from "drizzle-orm";
+import { validUniqueServerAppName } from "./project";
+
+import { execAsyncRemote } from "@/server/utils/process/execAsync";
+
+export type Mongo = typeof mongo.$inferSelect;
+
+export const createMongo = async (input: typeof apiCreateMongo._type) => {
+	input.appName =
+		`${input.appName}-${generatePassword(6)}` || generateAppName("postgres");
+	if (input.appName) {
+		const valid = await validUniqueServerAppName(input.appName);
+
+		if (!valid) {
+			throw new TRPCError({
+				code: "CONFLICT",
+				message: "Service with this 'AppName' already exists",
+			});
+		}
+	}
+
+	const newMongo = await db
+		.insert(mongo)
+		.values({
+			...input,
+			databasePassword: input.databasePassword
+				? input.databasePassword
+				: generatePassword(),
+		})
+		.returning()
+		.then((value) => value[0]);
+
+	if (!newMongo) {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Error input: Inserting mongo database",
+		});
+	}
+
+	return newMongo;
+};
+
+export const findMongoById = async (mongoId: string) => {
+	const result = await db.query.mongo.findFirst({
+		where: eq(mongo.mongoId, mongoId),
+		with: {
+			project: true,
+			mounts: true,
+			server: true,
+			backups: {
+				with: {
+					destination: true,
+				},
+			},
+		},
+	});
+	if (!result) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Mongo not found",
+		});
+	}
+	return result;
+};
+
+export const updateMongoById = async (
+	mongoId: string,
+	postgresData: Partial<Mongo>,
+) => {
+	const result = await db
+		.update(mongo)
+		.set({
+			...postgresData,
+		})
+		.where(eq(mongo.mongoId, mongoId))
+		.returning();
+
+	return result[0];
+};
+
+export const findMongoByBackupId = async (backupId: string) => {
+	const result = await db
+		.select({
+			...getTableColumns(mongo),
+		})
+		.from(mongo)
+		.innerJoin(backups, eq(mongo.mongoId, backups.mongoId))
+		.where(eq(backups.backupId, backupId))
+		.limit(1);
+
+	if (!result || !result[0]) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Mongo not found",
+		});
+	}
+	return result[0];
+};
+
+export const removeMongoById = async (mongoId: string) => {
+	const result = await db
+		.delete(mongo)
+		.where(eq(mongo.mongoId, mongoId))
+		.returning();
+
+	return result[0];
+};
+
+export const deployMongo = async (mongoId: string) => {
+	const mongo = await findMongoById(mongoId);
+	try {
+		if (mongo.serverId) {
+			await execAsyncRemote(mongo.serverId, `docker pull ${mongo.dockerImage}`);
+		} else {
+			await pullImage(mongo.dockerImage);
+		}
+
+		await buildMongo(mongo);
+		await updateMongoById(mongoId, {
+			applicationStatus: "done",
+		});
+	} catch (error) {
+		await updateMongoById(mongoId, {
+			applicationStatus: "error",
+		});
+
+		throw new TRPCError({
+			code: "INTERNAL_SERVER_ERROR",
+			message: `Error on deploy mongo${error}`,
+		});
+	}
+	return mongo;
+};

packages/server/src/services/mount.ts

@@ -0,0 +1,280 @@
+import path from "node:path";
+import { paths } from "@/server/constants";
+import { db } from "@/server/db";
+import {
+	type ServiceType,
+	type apiCreateMount,
+	mounts,
+} from "@/server/db/schema";
+import { createFile, getCreateFileCommand } from "@/server/utils/docker/utils";
+import { removeFileOrDirectory } from "@/server/utils/filesystem/directory";
+import { execAsyncRemote } from "@/server/utils/process/execAsync";
+import { TRPCError } from "@trpc/server";
+import { type SQL, eq, sql } from "drizzle-orm";
+
+export type Mount = typeof mounts.$inferSelect;
+
+export const createMount = async (input: typeof apiCreateMount._type) => {
+	try {
+		const { serviceId, ...rest } = input;
+		const value = await db
+			.insert(mounts)
+			.values({
+				...rest,
+				...(input.serviceType === "application" && {
+					applicationId: serviceId,
+				}),
+				...(input.serviceType === "postgres" && {
+					postgresId: serviceId,
+				}),
+				...(input.serviceType === "mariadb" && {
+					mariadbId: serviceId,
+				}),
+				...(input.serviceType === "mongo" && {
+					mongoId: serviceId,
+				}),
+				...(input.serviceType === "mysql" && {
+					mysqlId: serviceId,
+				}),
+				...(input.serviceType === "redis" && {
+					redisId: serviceId,
+				}),
+				...(input.serviceType === "compose" && {
+					composeId: serviceId,
+				}),
+			})
+			.returning()
+			.then((value) => value[0]);
+
+		if (!value) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: "Error input: Inserting mount",
+			});
+		}
+
+		if (value.type === "file") {
+			await createFileMount(value.mountId);
+		}
+		return value;
+	} catch (error) {
+		console.log(error);
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Error to create the mount",
+			cause: error,
+		});
+	}
+};
+
+export const createFileMount = async (mountId: string) => {
+	try {
+		const mount = await findMountById(mountId);
+		const baseFilePath = await getBaseFilesPath(mountId);
+
+		const serverId = await getServerId(mount);
+
+		if (serverId) {
+			const command = getCreateFileCommand(
+				baseFilePath,
+				mount.filePath || "",
+				mount.content || "",
+			);
+			await execAsyncRemote(serverId, command);
+		} else {
+			await createFile(baseFilePath, mount.filePath || "", mount.content || "");
+		}
+	} catch (error) {
+		console.log(`Error to create the file mount: ${error}`);
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Error to create the mount",
+			cause: error,
+		});
+	}
+};
+
+export const findMountById = async (mountId: string) => {
+	const mount = await db.query.mounts.findFirst({
+		where: eq(mounts.mountId, mountId),
+		with: {
+			application: true,
+			postgres: true,
+			mariadb: true,
+			mongo: true,
+			mysql: true,
+			redis: true,
+			compose: true,
+		},
+	});
+	if (!mount) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Mount not found",
+		});
+	}
+	return mount;
+};
+
+export const updateMount = async (
+	mountId: string,
+	mountData: Partial<Mount>,
+) => {
+	return await db.transaction(async (transaction) => {
+		const mount = await db
+			.update(mounts)
+			.set({
+				...mountData,
+			})
+			.where(eq(mounts.mountId, mountId))
+			.returning()
+			.then((value) => value[0]);
+
+		if (!mount) {
+			throw new TRPCError({
+				code: "NOT_FOUND",
+				message: "Mount not found",
+			});
+		}
+
+		if (mount.type === "file") {
+			await deleteFileMount(mountId);
+			await createFileMount(mountId);
+		}
+		return mount;
+	});
+};
+
+export const findMountsByApplicationId = async (
+	serviceId: string,
+	serviceType: ServiceType,
+) => {
+	const sqlChunks: SQL[] = [];
+
+	switch (serviceType) {
+		case "application":
+			sqlChunks.push(eq(mounts.applicationId, serviceId));
+			break;
+		case "postgres":
+			sqlChunks.push(eq(mounts.postgresId, serviceId));
+			break;
+		case "mariadb":
+			sqlChunks.push(eq(mounts.mariadbId, serviceId));
+			break;
+		case "mongo":
+			sqlChunks.push(eq(mounts.mongoId, serviceId));
+			break;
+		case "mysql":
+			sqlChunks.push(eq(mounts.mysqlId, serviceId));
+			break;
+		case "redis":
+			sqlChunks.push(eq(mounts.redisId, serviceId));
+			break;
+		default:
+			throw new Error(`Unknown service type: ${serviceType}`);
+	}
+	const mount = await db.query.mounts.findMany({
+		where: sql.join(sqlChunks, sql.raw(" ")),
+	});
+
+	return mount;
+};
+
+export const deleteMount = async (mountId: string) => {
+	const { type } = await findMountById(mountId);
+
+	if (type === "file") {
+		await deleteFileMount(mountId);
+	}
+
+	const deletedMount = await db
+		.delete(mounts)
+		.where(eq(mounts.mountId, mountId))
+		.returning();
+	return deletedMount[0];
+};
+
+export const deleteFileMount = async (mountId: string) => {
+	const mount = await findMountById(mountId);
+	if (!mount.filePath) return;
+	const basePath = await getBaseFilesPath(mountId);
+
+	const fullPath = path.join(basePath, mount.filePath);
+	try {
+		const serverId = await getServerId(mount);
+		if (serverId) {
+			const command = `rm -rf ${fullPath}`;
+			await execAsyncRemote(serverId, command);
+		} else {
+			await removeFileOrDirectory(fullPath);
+		}
+	} catch (error) {}
+};
+
+export const getBaseFilesPath = async (mountId: string) => {
+	const mount = await findMountById(mountId);
+
+	let absoluteBasePath = "";
+	let appName = "";
+	let directoryPath = "";
+
+	if (mount.serviceType === "application" && mount.application) {
+		const { APPLICATIONS_PATH } = paths(!!mount.application.serverId);
+		absoluteBasePath = path.resolve(APPLICATIONS_PATH);
+		appName = mount.application.appName;
+	} else if (mount.serviceType === "postgres" && mount.postgres) {
+		const { APPLICATIONS_PATH } = paths(!!mount.postgres.serverId);
+		absoluteBasePath = path.resolve(APPLICATIONS_PATH);
+		appName = mount.postgres.appName;
+	} else if (mount.serviceType === "mariadb" && mount.mariadb) {
+		const { APPLICATIONS_PATH } = paths(!!mount.mariadb.serverId);
+		absoluteBasePath = path.resolve(APPLICATIONS_PATH);
+		appName = mount.mariadb.appName;
+	} else if (mount.serviceType === "mongo" && mount.mongo) {
+		const { APPLICATIONS_PATH } = paths(!!mount.mongo.serverId);
+		absoluteBasePath = path.resolve(APPLICATIONS_PATH);
+		appName = mount.mongo.appName;
+	} else if (mount.serviceType === "mysql" && mount.mysql) {
+		const { APPLICATIONS_PATH } = paths(!!mount.mysql.serverId);
+		absoluteBasePath = path.resolve(APPLICATIONS_PATH);
+		appName = mount.mysql.appName;
+	} else if (mount.serviceType === "redis" && mount.redis) {
+		const { APPLICATIONS_PATH } = paths(!!mount.redis.serverId);
+		absoluteBasePath = path.resolve(APPLICATIONS_PATH);
+		appName = mount.redis.appName;
+	} else if (mount.serviceType === "compose" && mount.compose) {
+		const { COMPOSE_PATH } = paths(!!mount.compose.serverId);
+		appName = mount.compose.appName;
+		absoluteBasePath = path.resolve(COMPOSE_PATH);
+	}
+	directoryPath = path.join(absoluteBasePath, appName, "files");
+
+	return directoryPath;
+};
+
+type MountNested = Awaited<ReturnType<typeof findMountById>>;
+export const getServerId = async (mount: MountNested) => {
+	if (mount.serviceType === "application" && mount?.application?.serverId) {
+		return mount.application.serverId;
+	}
+	if (mount.serviceType === "postgres" && mount?.postgres?.serverId) {
+		return mount.postgres.serverId;
+	}
+	if (mount.serviceType === "mariadb" && mount?.mariadb?.serverId) {
+		return mount.mariadb.serverId;
+	}
+	if (mount.serviceType === "mongo" && mount?.mongo?.serverId) {
+		return mount.mongo.serverId;
+	}
+	if (mount.serviceType === "mysql" && mount?.mysql?.serverId) {
+		return mount.mysql.serverId;
+	}
+	if (mount.serviceType === "redis" && mount?.redis?.serverId) {
+		return mount.redis.serverId;
+	}
+	if (mount.serviceType === "compose" && mount?.compose?.serverId) {
+		return mount.compose.serverId;
+	}
+
+	return null;
+};

packages/server/src/services/mysql.ts

@@ -0,0 +1,144 @@
+import { db } from "@/server/db";
+import { type apiCreateMySql, backups, mysql } from "@/server/db/schema";
+import { generateAppName } from "@/server/db/schema";
+import { generatePassword } from "@/server/templates/utils";
+import { buildMysql } from "@/server/utils/databases/mysql";
+import { pullImage } from "@/server/utils/docker/utils";
+import { TRPCError } from "@trpc/server";
+import { eq, getTableColumns } from "drizzle-orm";
+import { validUniqueServerAppName } from "./project";
+
+import { execAsyncRemote } from "@/server/utils/process/execAsync";
+
+export type MySql = typeof mysql.$inferSelect;
+
+export const createMysql = async (input: typeof apiCreateMySql._type) => {
+	input.appName =
+		`${input.appName}-${generatePassword(6)}` || generateAppName("mysql");
+
+	if (input.appName) {
+		const valid = await validUniqueServerAppName(input.appName);
+
+		if (!valid) {
+			throw new TRPCError({
+				code: "CONFLICT",
+				message: "Service with this 'AppName' already exists",
+			});
+		}
+	}
+
+	const newMysql = await db
+		.insert(mysql)
+		.values({
+			...input,
+			databasePassword: input.databasePassword
+				? input.databasePassword
+				: generatePassword(),
+			databaseRootPassword: input.databaseRootPassword
+				? input.databaseRootPassword
+				: generatePassword(),
+		})
+		.returning()
+		.then((value) => value[0]);
+
+	if (!newMysql) {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Error input: Inserting mysql database",
+		});
+	}
+
+	return newMysql;
+};
+
+// https://github.com/drizzle-team/drizzle-orm/discussions/1483#discussioncomment-7523881
+export const findMySqlById = async (mysqlId: string) => {
+	const result = await db.query.mysql.findFirst({
+		where: eq(mysql.mysqlId, mysqlId),
+		with: {
+			project: true,
+			mounts: true,
+			server: true,
+			backups: {
+				with: {
+					destination: true,
+				},
+			},
+		},
+	});
+	if (!result) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "MySql not found",
+		});
+	}
+	return result;
+};
+
+export const updateMySqlById = async (
+	mysqlId: string,
+	mysqlData: Partial<MySql>,
+) => {
+	const result = await db
+		.update(mysql)
+		.set({
+			...mysqlData,
+		})
+		.where(eq(mysql.mysqlId, mysqlId))
+		.returning();
+
+	return result[0];
+};
+
+export const findMySqlByBackupId = async (backupId: string) => {
+	const result = await db
+		.select({
+			...getTableColumns(mysql),
+		})
+		.from(mysql)
+		.innerJoin(backups, eq(mysql.mysqlId, backups.mysqlId))
+		.where(eq(backups.backupId, backupId))
+		.limit(1);
+
+	if (!result || !result[0]) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Mysql not found",
+		});
+	}
+	return result[0];
+};
+
+export const removeMySqlById = async (mysqlId: string) => {
+	const result = await db
+		.delete(mysql)
+		.where(eq(mysql.mysqlId, mysqlId))
+		.returning();
+
+	return result[0];
+};
+
+export const deployMySql = async (mysqlId: string) => {
+	const mysql = await findMySqlById(mysqlId);
+	try {
+		if (mysql.serverId) {
+			await execAsyncRemote(mysql.serverId, `docker pull ${mysql.dockerImage}`);
+		} else {
+			await pullImage(mysql.dockerImage);
+		}
+
+		await buildMysql(mysql);
+		await updateMySqlById(mysqlId, {
+			applicationStatus: "done",
+		});
+	} catch (error) {
+		await updateMySqlById(mysqlId, {
+			applicationStatus: "error",
+		});
+		throw new TRPCError({
+			code: "INTERNAL_SERVER_ERROR",
+			message: `Error on deploy mysql${error}`,
+		});
+	}
+	return mysql;
+};

packages/server/src/services/notification.ts

@@ -0,0 +1,421 @@
+import { db } from "@/server/db";
+import {
+	type apiCreateDiscord,
+	type apiCreateEmail,
+	type apiCreateSlack,
+	type apiCreateTelegram,
+	type apiUpdateDiscord,
+	type apiUpdateEmail,
+	type apiUpdateSlack,
+	type apiUpdateTelegram,
+	discord,
+	email,
+	notifications,
+	slack,
+	telegram,
+} from "@/server/db/schema";
+import { TRPCError } from "@trpc/server";
+import { eq } from "drizzle-orm";
+
+export type Notification = typeof notifications.$inferSelect;
+
+export const createSlackNotification = async (
+	input: typeof apiCreateSlack._type,
+	adminId: string,
+) => {
+	await db.transaction(async (tx) => {
+		const newSlack = await tx
+			.insert(slack)
+			.values({
+				channel: input.channel,
+				webhookUrl: input.webhookUrl,
+			})
+			.returning()
+			.then((value) => value[0]);
+
+		if (!newSlack) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: "Error input: Inserting slack",
+			});
+		}
+
+		const newDestination = await tx
+			.insert(notifications)
+			.values({
+				slackId: newSlack.slackId,
+				name: input.name,
+				appDeploy: input.appDeploy,
+				appBuildError: input.appBuildError,
+				databaseBackup: input.databaseBackup,
+				dokployRestart: input.dokployRestart,
+				dockerCleanup: input.dockerCleanup,
+				notificationType: "slack",
+				adminId: adminId,
+			})
+			.returning()
+			.then((value) => value[0]);
+
+		if (!newDestination) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: "Error input: Inserting notification",
+			});
+		}
+
+		return newDestination;
+	});
+};
+
+export const updateSlackNotification = async (
+	input: typeof apiUpdateSlack._type,
+) => {
+	await db.transaction(async (tx) => {
+		const newDestination = await tx
+			.update(notifications)
+			.set({
+				name: input.name,
+				appDeploy: input.appDeploy,
+				appBuildError: input.appBuildError,
+				databaseBackup: input.databaseBackup,
+				dokployRestart: input.dokployRestart,
+				dockerCleanup: input.dockerCleanup,
+				adminId: input.adminId,
+			})
+			.where(eq(notifications.notificationId, input.notificationId))
+			.returning()
+			.then((value) => value[0]);
+
+		if (!newDestination) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: "Error Updating notification",
+			});
+		}
+
+		await tx
+			.update(slack)
+			.set({
+				channel: input.channel,
+				webhookUrl: input.webhookUrl,
+			})
+			.where(eq(slack.slackId, input.slackId))
+			.returning()
+			.then((value) => value[0]);
+
+		return newDestination;
+	});
+};
+
+export const createTelegramNotification = async (
+	input: typeof apiCreateTelegram._type,
+	adminId: string,
+) => {
+	await db.transaction(async (tx) => {
+		const newTelegram = await tx
+			.insert(telegram)
+			.values({
+				botToken: input.botToken,
+				chatId: input.chatId,
+			})
+			.returning()
+			.then((value) => value[0]);
+
+		if (!newTelegram) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: "Error input: Inserting telegram",
+			});
+		}
+
+		const newDestination = await tx
+			.insert(notifications)
+			.values({
+				telegramId: newTelegram.telegramId,
+				name: input.name,
+				appDeploy: input.appDeploy,
+				appBuildError: input.appBuildError,
+				databaseBackup: input.databaseBackup,
+				dokployRestart: input.dokployRestart,
+				dockerCleanup: input.dockerCleanup,
+				notificationType: "telegram",
+				adminId: adminId,
+			})
+			.returning()
+			.then((value) => value[0]);
+
+		if (!newDestination) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: "Error input: Inserting notification",
+			});
+		}
+
+		return newDestination;
+	});
+};
+
+export const updateTelegramNotification = async (
+	input: typeof apiUpdateTelegram._type,
+) => {
+	await db.transaction(async (tx) => {
+		const newDestination = await tx
+			.update(notifications)
+			.set({
+				name: input.name,
+				appDeploy: input.appDeploy,
+				appBuildError: input.appBuildError,
+				databaseBackup: input.databaseBackup,
+				dokployRestart: input.dokployRestart,
+				dockerCleanup: input.dockerCleanup,
+				adminId: input.adminId,
+			})
+			.where(eq(notifications.notificationId, input.notificationId))
+			.returning()
+			.then((value) => value[0]);
+
+		if (!newDestination) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: "Error Updating notification",
+			});
+		}
+
+		await tx
+			.update(telegram)
+			.set({
+				botToken: input.botToken,
+				chatId: input.chatId,
+			})
+			.where(eq(telegram.telegramId, input.telegramId))
+			.returning()
+			.then((value) => value[0]);
+
+		return newDestination;
+	});
+};
+
+export const createDiscordNotification = async (
+	input: typeof apiCreateDiscord._type,
+	adminId: string,
+) => {
+	await db.transaction(async (tx) => {
+		const newDiscord = await tx
+			.insert(discord)
+			.values({
+				webhookUrl: input.webhookUrl,
+			})
+			.returning()
+			.then((value) => value[0]);
+
+		if (!newDiscord) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: "Error input: Inserting discord",
+			});
+		}
+
+		const newDestination = await tx
+			.insert(notifications)
+			.values({
+				discordId: newDiscord.discordId,
+				name: input.name,
+				appDeploy: input.appDeploy,
+				appBuildError: input.appBuildError,
+				databaseBackup: input.databaseBackup,
+				dokployRestart: input.dokployRestart,
+				dockerCleanup: input.dockerCleanup,
+				notificationType: "discord",
+				adminId: adminId,
+			})
+			.returning()
+			.then((value) => value[0]);
+
+		if (!newDestination) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: "Error input: Inserting notification",
+			});
+		}
+
+		return newDestination;
+	});
+};
+
+export const updateDiscordNotification = async (
+	input: typeof apiUpdateDiscord._type,
+) => {
+	await db.transaction(async (tx) => {
+		const newDestination = await tx
+			.update(notifications)
+			.set({
+				name: input.name,
+				appDeploy: input.appDeploy,
+				appBuildError: input.appBuildError,
+				databaseBackup: input.databaseBackup,
+				dokployRestart: input.dokployRestart,
+				dockerCleanup: input.dockerCleanup,
+				adminId: input.adminId,
+			})
+			.where(eq(notifications.notificationId, input.notificationId))
+			.returning()
+			.then((value) => value[0]);
+
+		if (!newDestination) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: "Error Updating notification",
+			});
+		}
+
+		await tx
+			.update(discord)
+			.set({
+				webhookUrl: input.webhookUrl,
+			})
+			.where(eq(discord.discordId, input.discordId))
+			.returning()
+			.then((value) => value[0]);
+
+		return newDestination;
+	});
+};
+
+export const createEmailNotification = async (
+	input: typeof apiCreateEmail._type,
+	adminId: string,
+) => {
+	await db.transaction(async (tx) => {
+		const newEmail = await tx
+			.insert(email)
+			.values({
+				smtpServer: input.smtpServer,
+				smtpPort: input.smtpPort,
+				username: input.username,
+				password: input.password,
+				fromAddress: input.fromAddress,
+				toAddresses: input.toAddresses,
+			})
+			.returning()
+			.then((value) => value[0]);
+
+		if (!newEmail) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: "Error input: Inserting email",
+			});
+		}
+
+		const newDestination = await tx
+			.insert(notifications)
+			.values({
+				emailId: newEmail.emailId,
+				name: input.name,
+				appDeploy: input.appDeploy,
+				appBuildError: input.appBuildError,
+				databaseBackup: input.databaseBackup,
+				dokployRestart: input.dokployRestart,
+				dockerCleanup: input.dockerCleanup,
+				notificationType: "email",
+				adminId: adminId,
+			})
+			.returning()
+			.then((value) => value[0]);
+
+		if (!newDestination) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: "Error input: Inserting notification",
+			});
+		}
+
+		return newDestination;
+	});
+};
+
+export const updateEmailNotification = async (
+	input: typeof apiUpdateEmail._type,
+) => {
+	await db.transaction(async (tx) => {
+		const newDestination = await tx
+			.update(notifications)
+			.set({
+				name: input.name,
+				appDeploy: input.appDeploy,
+				appBuildError: input.appBuildError,
+				databaseBackup: input.databaseBackup,
+				dokployRestart: input.dokployRestart,
+				dockerCleanup: input.dockerCleanup,
+				adminId: input.adminId,
+			})
+			.where(eq(notifications.notificationId, input.notificationId))
+			.returning()
+			.then((value) => value[0]);
+
+		if (!newDestination) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: "Error Updating notification",
+			});
+		}
+
+		await tx
+			.update(email)
+			.set({
+				smtpServer: input.smtpServer,
+				smtpPort: input.smtpPort,
+				username: input.username,
+				password: input.password,
+				fromAddress: input.fromAddress,
+				toAddresses: input.toAddresses,
+			})
+			.where(eq(email.emailId, input.emailId))
+			.returning()
+			.then((value) => value[0]);
+
+		return newDestination;
+	});
+};
+
+export const findNotificationById = async (notificationId: string) => {
+	const notification = await db.query.notifications.findFirst({
+		where: eq(notifications.notificationId, notificationId),
+		with: {
+			slack: true,
+			telegram: true,
+			discord: true,
+			email: true,
+		},
+	});
+	if (!notification) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Notification not found",
+		});
+	}
+	return notification;
+};
+
+export const removeNotificationById = async (notificationId: string) => {
+	const result = await db
+		.delete(notifications)
+		.where(eq(notifications.notificationId, notificationId))
+		.returning();
+
+	return result[0];
+};
+
+export const updateNotificationById = async (
+	notificationId: string,
+	notificationData: Partial<Notification>,
+) => {
+	const result = await db
+		.update(notifications)
+		.set({
+			...notificationData,
+		})
+		.where(eq(notifications.notificationId, notificationId))
+		.returning();
+
+	return result[0];
+};

packages/server/src/services/port.ts

@@ -0,0 +1,62 @@
+import { db } from "@/server/db";
+import { type apiCreatePort, ports } from "@/server/db/schema";
+import { TRPCError } from "@trpc/server";
+import { eq } from "drizzle-orm";
+
+export type Port = typeof ports.$inferSelect;
+
+export const createPort = async (input: typeof apiCreatePort._type) => {
+	const newPort = await db
+		.insert(ports)
+		.values({
+			...input,
+		})
+		.returning()
+		.then((value) => value[0]);
+
+	if (!newPort) {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Error input: Inserting port",
+		});
+	}
+
+	return newPort;
+};
+
+export const finPortById = async (portId: string) => {
+	const result = await db.query.ports.findFirst({
+		where: eq(ports.portId, portId),
+	});
+	if (!result) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Port not found",
+		});
+	}
+	return result;
+};
+
+export const removePortById = async (portId: string) => {
+	const result = await db
+		.delete(ports)
+		.where(eq(ports.portId, portId))
+		.returning();
+
+	return result[0];
+};
+
+export const updatePortById = async (
+	portId: string,
+	portData: Partial<Port>,
+) => {
+	const result = await db
+		.update(ports)
+		.set({
+			...portData,
+		})
+		.where(eq(ports.portId, portId))
+		.returning();
+
+	return result[0];
+};

packages/server/src/services/postgres.ts

@@ -0,0 +1,142 @@
+import { db } from "@/server/db";
+import { type apiCreatePostgres, backups, postgres } from "@/server/db/schema";
+import { generateAppName } from "@/server/db/schema";
+import { generatePassword } from "@/server/templates/utils";
+import { buildPostgres } from "@/server/utils/databases/postgres";
+import { pullImage } from "@/server/utils/docker/utils";
+import { TRPCError } from "@trpc/server";
+import { eq, getTableColumns } from "drizzle-orm";
+import { validUniqueServerAppName } from "./project";
+
+import { execAsyncRemote } from "@/server/utils/process/execAsync";
+
+export type Postgres = typeof postgres.$inferSelect;
+
+export const createPostgres = async (input: typeof apiCreatePostgres._type) => {
+	input.appName =
+		`${input.appName}-${generatePassword(6)}` || generateAppName("postgres");
+	if (input.appName) {
+		const valid = await validUniqueServerAppName(input.appName);
+
+		if (!valid) {
+			throw new TRPCError({
+				code: "CONFLICT",
+				message: "Service with this 'AppName' already exists",
+			});
+		}
+	}
+
+	const newPostgres = await db
+		.insert(postgres)
+		.values({
+			...input,
+			databasePassword: input.databasePassword
+				? input.databasePassword
+				: generatePassword(),
+		})
+		.returning()
+		.then((value) => value[0]);
+
+	if (!newPostgres) {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Error input: Inserting postgresql database",
+		});
+	}
+
+	return newPostgres;
+};
+export const findPostgresById = async (postgresId: string) => {
+	const result = await db.query.postgres.findFirst({
+		where: eq(postgres.postgresId, postgresId),
+		with: {
+			project: true,
+			mounts: true,
+			server: true,
+			backups: {
+				with: {
+					destination: true,
+				},
+			},
+		},
+	});
+	if (!result) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Postgres not found",
+		});
+	}
+	return result;
+};
+
+export const findPostgresByBackupId = async (backupId: string) => {
+	const result = await db
+		.select({
+			...getTableColumns(postgres),
+		})
+		.from(postgres)
+		.innerJoin(backups, eq(postgres.postgresId, backups.postgresId))
+		.where(eq(backups.backupId, backupId))
+		.limit(1);
+
+	if (!result || !result[0]) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Postgres not found",
+		});
+	}
+	return result[0];
+};
+
+export const updatePostgresById = async (
+	postgresId: string,
+	postgresData: Partial<Postgres>,
+) => {
+	const result = await db
+		.update(postgres)
+		.set({
+			...postgresData,
+		})
+		.where(eq(postgres.postgresId, postgresId))
+		.returning();
+
+	return result[0];
+};
+
+export const removePostgresById = async (postgresId: string) => {
+	const result = await db
+		.delete(postgres)
+		.where(eq(postgres.postgresId, postgresId))
+		.returning();
+
+	return result[0];
+};
+
+export const deployPostgres = async (postgresId: string) => {
+	const postgres = await findPostgresById(postgresId);
+	try {
+		const promises = [];
+		if (postgres.serverId) {
+			const result = await execAsyncRemote(
+				postgres.serverId,
+				`docker pull ${postgres.dockerImage}`,
+			);
+		} else {
+			await pullImage(postgres.dockerImage);
+		}
+
+		await buildPostgres(postgres);
+		await updatePostgresById(postgresId, {
+			applicationStatus: "done",
+		});
+	} catch (error) {
+		await updatePostgresById(postgresId, {
+			applicationStatus: "error",
+		});
+		throw new TRPCError({
+			code: "INTERNAL_SERVER_ERROR",
+			message: `Error on deploy postgres${error}`,
+		});
+	}
+	return postgres;
+};

packages/server/src/services/project.ts

@@ -0,0 +1,124 @@
+import { db } from "@/server/db";
+import {
+	type apiCreateProject,
+	applications,
+	mariadb,
+	mongo,
+	mysql,
+	postgres,
+	projects,
+	redis,
+} from "@/server/db/schema";
+import { TRPCError } from "@trpc/server";
+import { eq } from "drizzle-orm";
+
+export type Project = typeof projects.$inferSelect;
+
+export const createProject = async (
+	input: typeof apiCreateProject._type,
+	adminId: string,
+) => {
+	const newProject = await db
+		.insert(projects)
+		.values({
+			...input,
+			adminId: adminId,
+		})
+		.returning()
+		.then((value) => value[0]);
+
+	if (!newProject) {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Error to create the project",
+		});
+	}
+
+	return newProject;
+};
+
+export const findProjectById = async (projectId: string) => {
+	const project = await db.query.projects.findFirst({
+		where: eq(projects.projectId, projectId),
+		with: {
+			applications: true,
+			mariadb: true,
+			mongo: true,
+			mysql: true,
+			postgres: true,
+			redis: true,
+			compose: true,
+		},
+	});
+	if (!project) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Project not found",
+		});
+	}
+	return project;
+};
+
+export const deleteProject = async (projectId: string) => {
+	const project = await db
+		.delete(projects)
+		.where(eq(projects.projectId, projectId))
+		.returning()
+		.then((value) => value[0]);
+
+	return project;
+};
+
+export const updateProjectById = async (
+	projectId: string,
+	projectData: Partial<Project>,
+) => {
+	const result = await db
+		.update(projects)
+		.set({
+			...projectData,
+		})
+		.where(eq(projects.projectId, projectId))
+		.returning()
+		.then((res) => res[0]);
+
+	return result;
+};
+
+export const validUniqueServerAppName = async (appName: string) => {
+	const query = await db.query.projects.findMany({
+		with: {
+			applications: {
+				where: eq(applications.appName, appName),
+			},
+			mariadb: {
+				where: eq(mariadb.appName, appName),
+			},
+			mongo: {
+				where: eq(mongo.appName, appName),
+			},
+			mysql: {
+				where: eq(mysql.appName, appName),
+			},
+			postgres: {
+				where: eq(postgres.appName, appName),
+			},
+			redis: {
+				where: eq(redis.appName, appName),
+			},
+		},
+	});
+
+	// Filter out items with non-empty fields
+	const nonEmptyProjects = query.filter(
+		(project) =>
+			project.applications.length > 0 ||
+			project.mariadb.length > 0 ||
+			project.mongo.length > 0 ||
+			project.mysql.length > 0 ||
+			project.postgres.length > 0 ||
+			project.redis.length > 0,
+	);
+
+	return nonEmptyProjects.length === 0;
+};

packages/server/src/services/redirect.ts

@@ -0,0 +1,123 @@
+import { db } from "@/server/db";
+import { type apiCreateRedirect, redirects } from "@/server/db/schema";
+import {
+	createRedirectMiddleware,
+	removeRedirectMiddleware,
+	updateRedirectMiddleware,
+} from "@/server/utils/traefik/redirect";
+import { TRPCError } from "@trpc/server";
+import { desc, eq } from "drizzle-orm";
+import type { z } from "zod";
+import { findApplicationById } from "./application";
+export type Redirect = typeof redirects.$inferSelect;
+
+export const findRedirectById = async (redirectId: string) => {
+	const application = await db.query.redirects.findFirst({
+		where: eq(redirects.redirectId, redirectId),
+	});
+	if (!application) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Redirect not found",
+		});
+	}
+	return application;
+};
+
+export const createRedirect = async (
+	redirectData: z.infer<typeof apiCreateRedirect>,
+) => {
+	try {
+		await db.transaction(async (tx) => {
+			const redirect = await tx
+				.insert(redirects)
+				.values({
+					...redirectData,
+				})
+				.returning()
+				.then((res) => res[0]);
+
+			if (!redirect) {
+				throw new TRPCError({
+					code: "BAD_REQUEST",
+					message: "Error to create the redirect",
+				});
+			}
+
+			const application = await findApplicationById(redirect.applicationId);
+
+			createRedirectMiddleware(application, redirect);
+		});
+
+		return true;
+	} catch (error) {
+		console.log(error);
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Error to create this redirect",
+			cause: error,
+		});
+	}
+};
+
+export const removeRedirectById = async (redirectId: string) => {
+	try {
+		const response = await db
+			.delete(redirects)
+			.where(eq(redirects.redirectId, redirectId))
+			.returning()
+			.then((res) => res[0]);
+
+		if (!response) {
+			throw new TRPCError({
+				code: "NOT_FOUND",
+				message: "Redirect not found",
+			});
+		}
+
+		const application = await findApplicationById(response.applicationId);
+
+		await removeRedirectMiddleware(application, response);
+
+		return response;
+	} catch (error) {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Error to remove this redirect",
+			cause: error,
+		});
+	}
+};
+
+export const updateRedirectById = async (
+	redirectId: string,
+	redirectData: Partial<Redirect>,
+) => {
+	try {
+		const redirect = await db
+			.update(redirects)
+			.set({
+				...redirectData,
+			})
+			.where(eq(redirects.redirectId, redirectId))
+			.returning()
+			.then((res) => res[0]);
+
+		if (!redirect) {
+			throw new TRPCError({
+				code: "NOT_FOUND",
+				message: "Redirect not found",
+			});
+		}
+		const application = await findApplicationById(redirect.applicationId);
+
+		await updateRedirectMiddleware(application, redirect);
+
+		return redirect;
+	} catch (error) {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Error to update this redirect",
+		});
+	}
+};

packages/server/src/services/redis.ts

@@ -0,0 +1,117 @@
+import { db } from "@/server/db";
+import { type apiCreateRedis, redis } from "@/server/db/schema";
+import { generateAppName } from "@/server/db/schema";
+import { generatePassword } from "@/server/templates/utils";
+import { buildRedis } from "@/server/utils/databases/redis";
+import { pullImage } from "@/server/utils/docker/utils";
+import { TRPCError } from "@trpc/server";
+import { eq } from "drizzle-orm";
+import { validUniqueServerAppName } from "./project";
+
+import { execAsyncRemote } from "@/server/utils/process/execAsync";
+
+export type Redis = typeof redis.$inferSelect;
+
+// https://github.com/drizzle-team/drizzle-orm/discussions/1483#discussioncomment-7523881
+export const createRedis = async (input: typeof apiCreateRedis._type) => {
+	input.appName =
+		`${input.appName}-${generatePassword(6)}` || generateAppName("redis");
+	if (input.appName) {
+		const valid = await validUniqueServerAppName(input.appName);
+
+		if (!valid) {
+			throw new TRPCError({
+				code: "CONFLICT",
+				message: "Service with this 'AppName' already exists",
+			});
+		}
+	}
+
+	const newRedis = await db
+		.insert(redis)
+		.values({
+			...input,
+			databasePassword: input.databasePassword
+				? input.databasePassword
+				: generatePassword(),
+		})
+		.returning()
+		.then((value) => value[0]);
+
+	if (!newRedis) {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Error input: Inserting redis database",
+		});
+	}
+
+	return newRedis;
+};
+
+export const findRedisById = async (redisId: string) => {
+	const result = await db.query.redis.findFirst({
+		where: eq(redis.redisId, redisId),
+		with: {
+			project: true,
+			mounts: true,
+			server: true,
+		},
+	});
+	if (!result) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Redis not found",
+		});
+	}
+	return result;
+};
+
+export const updateRedisById = async (
+	redisId: string,
+	redisData: Partial<Redis>,
+) => {
+	const result = await db
+		.update(redis)
+		.set({
+			...redisData,
+		})
+		.where(eq(redis.redisId, redisId))
+		.returning();
+
+	return result[0];
+};
+
+export const removeRedisById = async (redisId: string) => {
+	const result = await db
+		.delete(redis)
+		.where(eq(redis.redisId, redisId))
+		.returning();
+
+	return result[0];
+};
+
+export const deployRedis = async (redisId: string) => {
+	const redis = await findRedisById(redisId);
+	try {
+		if (redis.serverId) {
+			await execAsyncRemote(redis.serverId, `docker pull ${redis.dockerImage}`);
+		} else {
+			await pullImage(redis.dockerImage);
+		}
+
+		await buildRedis(redis);
+		await updateRedisById(redisId, {
+			applicationStatus: "done",
+		});
+	} catch (error) {
+		await updateRedisById(redisId, {
+			applicationStatus: "error",
+		});
+
+		throw new TRPCError({
+			code: "INTERNAL_SERVER_ERROR",
+			message: `Error on deploy redis${error}`,
+		});
+	}
+	return redis;
+};

packages/server/src/services/registry.ts

@@ -0,0 +1,134 @@
+import { db } from "@/server/db";
+import { type apiCreateRegistry, registry } from "@/server/db/schema";
+import { initializeRegistry } from "@/server/setup/registry-setup";
+import { removeService } from "@/server/utils/docker/utils";
+import { execAsync, execAsyncRemote } from "@/server/utils/process/execAsync";
+import {
+	manageRegistry,
+	removeSelfHostedRegistry,
+} from "@/server/utils/traefik/registry";
+import { TRPCError } from "@trpc/server";
+import { eq } from "drizzle-orm";
+
+export type Registry = typeof registry.$inferSelect;
+
+export const createRegistry = async (
+	input: typeof apiCreateRegistry._type,
+	adminId: string,
+) => {
+	return await db.transaction(async (tx) => {
+		const newRegistry = await tx
+			.insert(registry)
+			.values({
+				...input,
+				adminId: adminId,
+			})
+			.returning()
+			.then((value) => value[0]);
+
+		if (!newRegistry) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: "Error input:  Inserting registry",
+			});
+		}
+		const loginCommand = `echo ${input.password} | docker login ${input.registryUrl} --username ${input.username} --password-stdin`;
+		if (input.serverId && input.serverId !== "none") {
+			await execAsyncRemote(input.serverId, loginCommand);
+		} else if (newRegistry.registryType === "cloud") {
+			await execAsync(loginCommand);
+		}
+
+		return newRegistry;
+	});
+};
+
+export const removeRegistry = async (registryId: string) => {
+	try {
+		const response = await db
+			.delete(registry)
+			.where(eq(registry.registryId, registryId))
+			.returning()
+			.then((res) => res[0]);
+
+		if (!response) {
+			throw new TRPCError({
+				code: "NOT_FOUND",
+				message: "Registry not found",
+			});
+		}
+
+		if (response.registryType === "selfHosted") {
+			await removeSelfHostedRegistry();
+			await removeService("dokploy-registry");
+		}
+
+		await execAsync(`docker logout ${response.registryUrl}`);
+
+		return response;
+	} catch (error) {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Error to remove this registry",
+			cause: error,
+		});
+	}
+};
+
+export const updateRegistry = async (
+	registryId: string,
+	registryData: Partial<Registry> & { serverId?: string | null },
+) => {
+	try {
+		const response = await db
+			.update(registry)
+			.set({
+				...registryData,
+			})
+			.where(eq(registry.registryId, registryId))
+			.returning()
+			.then((res) => res[0]);
+
+		if (response?.registryType === "selfHosted") {
+			await manageRegistry(response);
+			await initializeRegistry(response.username, response.password);
+		}
+		const loginCommand = `echo ${response?.password} | docker login ${response?.registryUrl} --username ${response?.username} --password-stdin`;
+
+		if (registryData?.serverId && registryData?.serverId !== "none") {
+			await execAsyncRemote(registryData.serverId, loginCommand);
+		} else if (response?.registryType === "cloud") {
+			await execAsync(loginCommand);
+		}
+
+		return response;
+	} catch (error) {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Error to update this registry",
+		});
+	}
+};
+
+export const findRegistryById = async (registryId: string) => {
+	const registryResponse = await db.query.registry.findFirst({
+		where: eq(registry.registryId, registryId),
+		columns: {
+			password: false,
+		},
+	});
+	if (!registryResponse) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Registry not found",
+		});
+	}
+	return registryResponse;
+};
+
+export const findAllRegistryByAdminId = async (adminId: string) => {
+	const registryResponse = await db.query.registry.findMany({
+		where: eq(registry.adminId, adminId),
+	});
+	return registryResponse;
+};

packages/server/src/services/security.ts

@@ -0,0 +1,107 @@
+import { db } from "@/server/db";
+import { type apiCreateSecurity, security } from "@/server/db/schema";
+import {
+	createSecurityMiddleware,
+	removeSecurityMiddleware,
+} from "@/server/utils/traefik/security";
+import { TRPCError } from "@trpc/server";
+import { eq } from "drizzle-orm";
+import type { z } from "zod";
+import { findApplicationById } from "./application";
+export type Security = typeof security.$inferSelect;
+
+export const findSecurityById = async (securityId: string) => {
+	const application = await db.query.security.findFirst({
+		where: eq(security.securityId, securityId),
+	});
+	if (!application) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Security not found",
+		});
+	}
+	return application;
+};
+
+export const createSecurity = async (
+	data: z.infer<typeof apiCreateSecurity>,
+) => {
+	try {
+		await db.transaction(async (tx) => {
+			const application = await findApplicationById(data.applicationId);
+
+			const securityResponse = await tx
+				.insert(security)
+				.values({
+					...data,
+				})
+				.returning()
+				.then((res) => res[0]);
+
+			if (!securityResponse) {
+				throw new TRPCError({
+					code: "BAD_REQUEST",
+					message: "Error to create the security",
+				});
+			}
+			await createSecurityMiddleware(application, securityResponse);
+			return true;
+		});
+	} catch (error) {
+		console.log(error);
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Error to create this security",
+			cause: error,
+		});
+	}
+};
+
+export const deleteSecurityById = async (securityId: string) => {
+	try {
+		const result = await db
+			.delete(security)
+			.where(eq(security.securityId, securityId))
+			.returning()
+			.then((res) => res[0]);
+
+		if (!result) {
+			throw new TRPCError({
+				code: "NOT_FOUND",
+				message: "Security not found",
+			});
+		}
+
+		const application = await findApplicationById(result.applicationId);
+
+		await removeSecurityMiddleware(application, result);
+		return result;
+	} catch (error) {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Error to remove this security",
+		});
+	}
+};
+
+export const updateSecurityById = async (
+	securityId: string,
+	data: Partial<Security>,
+) => {
+	try {
+		const response = await db
+			.update(security)
+			.set({
+				...data,
+			})
+			.where(eq(security.securityId, securityId))
+			.returning();
+
+		return response[0];
+	} catch (error) {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Error to update this security",
+		});
+	}
+};

packages/server/src/services/server.ts

@@ -0,0 +1,120 @@
+import { db } from "@/server/db";
+import { type apiCreateServer, server } from "@/server/db/schema";
+import { TRPCError } from "@trpc/server";
+import { desc, eq } from "drizzle-orm";
+
+export type Server = typeof server.$inferSelect;
+
+export const createServer = async (
+	input: typeof apiCreateServer._type,
+	adminId: string,
+) => {
+	const newServer = await db
+		.insert(server)
+		.values({
+			...input,
+			adminId: adminId,
+		})
+		.returning()
+		.then((value) => value[0]);
+
+	if (!newServer) {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Error to create the server",
+		});
+	}
+
+	return newServer;
+};
+
+export const findServerById = async (serverId: string) => {
+	const currentServer = await db.query.server.findFirst({
+		where: eq(server.serverId, serverId),
+		with: {
+			deployments: true,
+			sshKey: true,
+		},
+	});
+	if (!currentServer) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Server not found",
+		});
+	}
+	return currentServer;
+};
+
+export const findServersByAdminId = async (adminId: string) => {
+	const servers = await db.query.server.findMany({
+		where: eq(server.adminId, adminId),
+		orderBy: desc(server.createdAt),
+	});
+
+	return servers;
+};
+
+export const deleteServer = async (serverId: string) => {
+	const currentServer = await db
+		.delete(server)
+		.where(eq(server.serverId, serverId))
+		.returning()
+		.then((value) => value[0]);
+
+	return currentServer;
+};
+
+export const haveActiveServices = async (serverId: string) => {
+	const currentServer = await db.query.server.findFirst({
+		where: eq(server.serverId, serverId),
+		with: {
+			applications: true,
+			compose: true,
+			redis: true,
+			mariadb: true,
+			mongo: true,
+			mysql: true,
+			postgres: true,
+		},
+	});
+
+	if (!currentServer) {
+		return false;
+	}
+
+	const total =
+		currentServer?.applications?.length +
+		currentServer?.compose?.length +
+		currentServer?.redis?.length +
+		currentServer?.mariadb?.length +
+		currentServer?.mongo?.length +
+		currentServer?.mysql?.length +
+		currentServer?.postgres?.length;
+
+	if (total === 0) {
+		return false;
+	}
+
+	return true;
+};
+
+export const updateServerById = async (
+	serverId: string,
+	serverData: Partial<Server>,
+) => {
+	const result = await db
+		.update(server)
+		.set({
+			...serverData,
+		})
+		.where(eq(server.serverId, serverId))
+		.returning()
+		.then((res) => res[0]);
+
+	return result;
+};
+
+export const getAllServers = async () => {
+	const servers = await db.query.server.findMany();
+	return servers;
+};

packages/server/src/services/settings.ts

@@ -0,0 +1,148 @@
+import { readdirSync } from "node:fs";
+import { join } from "node:path";
+import { docker } from "@/server/constants";
+import { getServiceContainer } from "@/server/utils/docker/utils";
+import { execAsyncRemote } from "@/server/utils/process/execAsync";
+// import packageInfo from "../../../package.json";
+
+const updateIsAvailable = async () => {
+	try {
+		const service = await getServiceContainer("dokploy");
+
+		const localImage = await docker.getImage(getDokployImage()).inspect();
+		return localImage.Id !== service?.ImageID;
+	} catch (error) {
+		return false;
+	}
+};
+
+export const getDokployImage = () => {
+	return `dokploy/dokploy:${process.env.RELEASE_TAG || "latest"}`;
+};
+
+export const pullLatestRelease = async () => {
+	try {
+		const stream = await docker.pull(getDokployImage(), {});
+		await new Promise((resolve, reject) => {
+			docker.modem.followProgress(stream, (err, res) =>
+				err ? reject(err) : resolve(res),
+			);
+		});
+		const newUpdateIsAvailable = await updateIsAvailable();
+		return newUpdateIsAvailable;
+	} catch (error) {}
+
+	return false;
+};
+export const getDokployVersion = () => {
+	// return packageInfo.version;
+};
+
+interface TreeDataItem {
+	id: string;
+	name: string;
+	type: "file" | "directory";
+	children?: TreeDataItem[];
+}
+
+export const readDirectory = async (
+	dirPath: string,
+	serverId?: string,
+): Promise<TreeDataItem[]> => {
+	if (serverId) {
+		const { stdout } = await execAsyncRemote(
+			serverId,
+			`
+process_items() {
+    local parent_dir="$1"
+    local __resultvar=$2
+
+    local items_json=""
+    local first=true
+    for item in "$parent_dir"/*; do
+        [ -e "$item" ] || continue
+        process_item "$item" item_json
+        if [ "$first" = true ]; then
+            first=false
+            items_json="$item_json"
+        else
+            items_json="$items_json,$item_json"
+        fi
+    done
+
+    eval $__resultvar="'[$items_json]'"
+}
+
+process_item() {
+    local item_path="$1"
+    local __resultvar=$2
+
+    local item_name=$(basename "$item_path")
+    local escaped_name=$(echo "$item_name" | sed 's/"/\\"/g')
+    local escaped_path=$(echo "$item_path" | sed 's/"/\\"/g')
+
+    if [ -d "$item_path" ]; then
+        # Is directory
+        process_items "$item_path" children_json
+        local json='{"id":"'"$escaped_path"'","name":"'"$escaped_name"'","type":"directory","children":'"$children_json"'}'
+    else
+        # Is file
+        local json='{"id":"'"$escaped_path"'","name":"'"$escaped_name"'","type":"file"}'
+    fi
+
+    eval $__resultvar="'$json'"
+}
+
+root_dir=${dirPath}
+
+process_items "$root_dir" json_output
+
+echo "$json_output"
+			`,
+		);
+		const result = JSON.parse(stdout);
+		return result;
+	}
+	const items = readdirSync(dirPath, { withFileTypes: true });
+
+	const stack = [dirPath];
+	const result: TreeDataItem[] = [];
+	const parentMap: Record<string, TreeDataItem[]> = {};
+
+	while (stack.length > 0) {
+		const currentPath = stack.pop();
+		if (!currentPath) continue;
+
+		const items = readdirSync(currentPath, { withFileTypes: true });
+		const currentDirectoryResult: TreeDataItem[] = [];
+
+		for (const item of items) {
+			const fullPath = join(currentPath, item.name);
+			if (item.isDirectory()) {
+				stack.push(fullPath);
+				const directoryItem: TreeDataItem = {
+					id: fullPath,
+					name: item.name,
+					type: "directory",
+					children: [],
+				};
+				currentDirectoryResult.push(directoryItem);
+				parentMap[fullPath] = directoryItem.children as TreeDataItem[];
+			} else {
+				const fileItem: TreeDataItem = {
+					id: fullPath,
+					name: item.name,
+					type: "file",
+				};
+				currentDirectoryResult.push(fileItem);
+			}
+		}
+
+		if (parentMap[currentPath]) {
+			parentMap[currentPath].push(...currentDirectoryResult);
+		} else {
+			result.push(...currentDirectoryResult);
+		}
+	}
+	return result;
+};

packages/server/src/services/ssh-key.ts

@@ -0,0 +1,68 @@
+import { db } from "@/server/db";
+import {
+	type apiCreateSshKey,
+	type apiFindOneSshKey,
+	type apiRemoveSshKey,
+	type apiUpdateSshKey,
+	sshKeys,
+} from "@/server/db/schema";
+import { TRPCError } from "@trpc/server";
+import { eq } from "drizzle-orm";
+
+export const createSshKey = async (input: typeof apiCreateSshKey._type) => {
+	await db.transaction(async (tx) => {
+		const sshKey = await tx
+			.insert(sshKeys)
+			.values(input)
+			.returning()
+			.then((response) => response[0])
+			.catch((e) => console.error(e));
+
+		if (!sshKey) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: "Error to create the ssh key",
+			});
+		}
+		return sshKey;
+	});
+};
+
+export const removeSSHKeyById = async (
+	sshKeyId: (typeof apiRemoveSshKey._type)["sshKeyId"],
+) => {
+	const result = await db
+		.delete(sshKeys)
+		.where(eq(sshKeys.sshKeyId, sshKeyId))
+		.returning();
+
+	return result[0];
+};
+
+export const updateSSHKeyById = async ({
+	sshKeyId,
+	...input
+}: typeof apiUpdateSshKey._type) => {
+	const result = await db
+		.update(sshKeys)
+		.set(input)
+		.where(eq(sshKeys.sshKeyId, sshKeyId))
+		.returning();
+
+	return result[0];
+};
+
+export const findSSHKeyById = async (
+	sshKeyId: (typeof apiFindOneSshKey._type)["sshKeyId"],
+) => {
+	const sshKey = await db.query.sshKeys.findFirst({
+		where: eq(sshKeys.sshKeyId, sshKeyId),
+	});
+	if (!sshKey) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "SSH Key not found",
+		});
+	}
+	return sshKey;
+};

packages/server/src/services/user.ts

@@ -0,0 +1,208 @@
+import { db } from "@/server/db";
+import { users } from "@/server/db/schema";
+import { TRPCError } from "@trpc/server";
+import { eq } from "drizzle-orm";
+
+export type User = typeof users.$inferSelect;
+
+export const findUserById = async (userId: string) => {
+	const user = await db.query.users.findFirst({
+		where: eq(users.userId, userId),
+	});
+	if (!user) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "User not found",
+		});
+	}
+	return user;
+};
+
+export const findUserByAuthId = async (authId: string) => {
+	const user = await db.query.users.findFirst({
+		where: eq(users.authId, authId),
+		with: {
+			auth: true,
+		},
+	});
+	if (!user) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "User not found",
+		});
+	}
+	return user;
+};
+
+export const findUsers = async (adminId: string) => {
+	const currentUsers = await db.query.users.findMany({
+		where: eq(users.adminId, adminId),
+		with: {
+			auth: {
+				columns: {
+					secret: false,
+				},
+			},
+		},
+	});
+	return currentUsers;
+};
+
+export const addNewProject = async (authId: string, projectId: string) => {
+	const user = await findUserByAuthId(authId);
+
+	await db
+		.update(users)
+		.set({
+			accesedProjects: [...user.accesedProjects, projectId],
+		})
+		.where(eq(users.authId, authId));
+};
+
+export const addNewService = async (authId: string, serviceId: string) => {
+	const user = await findUserByAuthId(authId);
+	await db
+		.update(users)
+		.set({
+			accesedServices: [...user.accesedServices, serviceId],
+		})
+		.where(eq(users.authId, authId));
+};
+
+export const canPerformCreationService = async (
+	userId: string,
+	projectId: string,
+) => {
+	const { accesedProjects, canCreateServices } = await findUserByAuthId(userId);
+	const haveAccessToProject = accesedProjects.includes(projectId);
+
+	if (canCreateServices && haveAccessToProject) {
+		return true;
+	}
+
+	return false;
+};
+
+export const canPerformAccessService = async (
+	userId: string,
+	serviceId: string,
+) => {
+	const { accesedServices } = await findUserByAuthId(userId);
+	const haveAccessToService = accesedServices.includes(serviceId);
+
+	if (haveAccessToService) {
+		return true;
+	}
+
+	return false;
+};
+
+export const canPeformDeleteService = async (
+	authId: string,
+	serviceId: string,
+) => {
+	const { accesedServices, canDeleteServices } = await findUserByAuthId(authId);
+	const haveAccessToService = accesedServices.includes(serviceId);
+
+	if (canDeleteServices && haveAccessToService) {
+		return true;
+	}
+
+	return false;
+};
+
+export const canPerformCreationProject = async (authId: string) => {
+	const { canCreateProjects } = await findUserByAuthId(authId);
+
+	if (canCreateProjects) {
+		return true;
+	}
+
+	return false;
+};
+
+export const canPerformDeleteProject = async (authId: string) => {
+	const { canDeleteProjects } = await findUserByAuthId(authId);
+
+	if (canDeleteProjects) {
+		return true;
+	}
+
+	return false;
+};
+
+export const canPerformAccessProject = async (
+	authId: string,
+	projectId: string,
+) => {
+	const { accesedProjects } = await findUserByAuthId(authId);
+
+	const haveAccessToProject = accesedProjects.includes(projectId);
+
+	if (haveAccessToProject) {
+		return true;
+	}
+	return false;
+};
+
+export const canAccessToTraefikFiles = async (authId: string) => {
+	const { canAccessToTraefikFiles } = await findUserByAuthId(authId);
+	return canAccessToTraefikFiles;
+};
+
+export const checkServiceAccess = async (
+	authId: string,
+	serviceId: string,
+	action = "access" as "access" | "create" | "delete",
+) => {
+	let hasPermission = false;
+	switch (action) {
+		case "create":
+			hasPermission = await canPerformCreationService(authId, serviceId);
+			break;
+		case "access":
+			hasPermission = await canPerformAccessService(authId, serviceId);
+			break;
+		case "delete":
+			hasPermission = await canPeformDeleteService(authId, serviceId);
+			break;
+		default:
+			hasPermission = false;
+	}
+	if (!hasPermission) {
+		throw new TRPCError({
+			code: "UNAUTHORIZED",
+			message: "Permission denied",
+		});
+	}
+};
+
+export const checkProjectAccess = async (
+	authId: string,
+	action: "create" | "delete" | "access",
+	projectId?: string,
+) => {
+	let hasPermission = false;
+	switch (action) {
+		case "access":
+			hasPermission = await canPerformAccessProject(
+				authId,
+				projectId as string,
+			);
+			break;
+		case "create":
+			hasPermission = await canPerformCreationProject(authId);
+			break;
+		case "delete":
+			hasPermission = await canPerformDeleteProject(authId);
+			break;
+		default:
+			hasPermission = false;
+	}
+	if (!hasPermission) {
+		throw new TRPCError({
+			code: "UNAUTHORIZED",
+			message: "Permission denied",
+		});
+	}
+};