Merge branch 'canary' into 1345-domain-not-working-after-server-restart-or-traefik-reload

packages/server/src/services/admin.ts

@@ -1,124 +1,59 @@
-import { randomBytes } from "node:crypto";
 import { db } from "@dokploy/server/db";
 import {
-	admins,
-	type apiCreateUserInvitation,
-	auth,
-	users,
+	invitation,
+	member,
+	organization,
+	users_temp,
 } from "@dokploy/server/db/schema";
 import { TRPCError } from "@trpc/server";
-import * as bcrypt from "bcrypt";
 import { eq } from "drizzle-orm";
 import { IS_CLOUD } from "../constants";
 
-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.toLowerCase(),
-				rol: "user",
-				password: bcrypt.hashSync("01231203012312", 10),
-			})
-			.returning()
-			.then((res) => res[0]);
-
-		if (!result) {
-			throw new TRPCError({
-				code: "BAD_REQUEST",
-				message: "Error creating 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 findUserById = async (userId: string) => {
+	const user = await db.query.users_temp.findFirst({
+		where: eq(users_temp.id, userId),
+		// with: {
+		// 	account: true,
+		// },
 	});
-};
-
-export const findAdminById = async (adminId: string) => {
-	const admin = await db.query.admins.findFirst({
-		where: eq(admins.adminId, adminId),
-	});
-	if (!admin) {
+	if (!user) {
 		throw new TRPCError({
 			code: "NOT_FOUND",
-			message: "Admin not found",
+			message: "User not found",
 		});
 	}
-	return admin;
+	return user;
 };
 
-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 updateAdminById = async (
-	adminId: string,
-	adminData: Partial<Admin>,
-) => {
-	const admin = await db
-		.update(admins)
-		.set({
-			...adminData,
-		})
-		.where(eq(admins.adminId, adminId))
-		.returning()
-		.then((res) => res[0]);
-
-	return admin;
+export const findOrganizationById = async (organizationId: string) => {
+	const organizationResult = await db.query.organization.findFirst({
+		where: eq(organization.id, organizationId),
+		with: {
+			owner: true,
+		},
+	});
+	return organizationResult;
 };
 
 export const isAdminPresent = async () => {
-	const admin = await db.query.admins.findFirst();
+	const admin = await db.query.member.findFirst({
+		where: eq(member.role, "owner"),
+	});
+
 	if (!admin) {
 		return false;
 	}
 	return true;
 };
 
-export const findAdminByAuthId = async (authId: string) => {
-	const admin = await db.query.admins.findFirst({
-		where: eq(admins.authId, authId),
+export const findAdmin = async () => {
+	const admin = await db.query.member.findFirst({
+		where: eq(member.role, "owner"),
 		with: {
-			users: true,
+			user: true,
 		},
 	});
-	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",
@@ -129,14 +64,15 @@ export const findAdmin = async () => {
 };
 
 export const getUserByToken = async (token: string) => {
-	const user = await db.query.users.findFirst({
-		where: eq(users.token, token),
-		with: {
-			auth: {
-				columns: {
-					password: false,
-				},
-			},
+	const user = await db.query.invitation.findFirst({
+		where: eq(invitation.id, token),
+		columns: {
+			id: true,
+			email: true,
+			status: true,
+			expiresAt: true,
+			role: true,
+			inviterId: true,
 		},
 	});
 
@@ -146,34 +82,23 @@ export const getUserByToken = async (token: string) => {
 			message: "Invitation not found",
 		});
 	}
+
+	const userAlreadyExists = await db.query.users_temp.findFirst({
+		where: eq(users_temp.email, user?.email || ""),
+	});
+
+	const { expiresAt, ...rest } = user;
 	return {
-		...user,
-		isExpired: user.isRegistered,
+		...rest,
+		isExpired: user.expiresAt < new Date(),
+		userAlreadyExists: !!userAlreadyExists,
 	};
 };
 
-export const removeUserByAuthId = async (authId: string) => {
+export const removeUserById = async (userId: string) => {
 	await db
-		.delete(auth)
-		.where(eq(auth.id, authId))
-		.returning()
-		.then((res) => res[0]);
-};
-
-export const removeAdminByAuthId = async (authId: string) => {
-	const admin = await findAdminByAuthId(authId);
-	if (!admin) return null;
-
-	// First delete all associated users
-	const users = admin.users;
-
-	for (const user of users) {
-		await removeUserByAuthId(user.authId);
-	}
-	// Then delete the auth record which will cascade delete the admin
-	return await db
-		.delete(auth)
-		.where(eq(auth.id, authId))
+		.delete(users_temp)
+		.where(eq(users_temp.id, userId))
 		.returning()
 		.then((res) => res[0]);
 };
@@ -184,8 +109,8 @@ export const getDokployUrl = async () => {
 	}
 	const admin = await findAdmin();
 
-	if (admin.host) {
-		return `https://${admin.host}`;
+	if (admin.user.host) {
+		return `https://${admin.user.host}`;
 	}
-	return `http://${admin.serverIp}:${process.env.PORT}`;
+	return `http://${admin.user.serverIp}:${process.env.PORT}`;
 };

packages/server/src/services/ai.ts

@@ -0,0 +1,212 @@
+import { db } from "@dokploy/server/db";
+import { ai } from "@dokploy/server/db/schema";
+import { selectAIProvider } from "@dokploy/server/utils/ai/select-ai-provider";
+import { TRPCError } from "@trpc/server";
+import { generateObject } from "ai";
+import { desc, eq } from "drizzle-orm";
+import { z } from "zod";
+import { IS_CLOUD } from "../constants";
+import { findServerById } from "./server";
+import { findOrganizationById } from "./admin";
+
+export const getAiSettingsByOrganizationId = async (organizationId: string) => {
+	const aiSettings = await db.query.ai.findMany({
+		where: eq(ai.organizationId, organizationId),
+		orderBy: desc(ai.createdAt),
+	});
+	return aiSettings;
+};
+
+export const getAiSettingById = async (aiId: string) => {
+	const aiSetting = await db.query.ai.findFirst({
+		where: eq(ai.aiId, aiId),
+	});
+	if (!aiSetting) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "AI settings not found",
+		});
+	}
+	return aiSetting;
+};
+
+export const saveAiSettings = async (organizationId: string, settings: any) => {
+	const aiId = settings.aiId;
+
+	return db
+		.insert(ai)
+		.values({
+			aiId,
+			organizationId,
+			...settings,
+		})
+		.onConflictDoUpdate({
+			target: ai.aiId,
+			set: {
+				...settings,
+			},
+		});
+};
+
+export const deleteAiSettings = async (aiId: string) => {
+	return db.delete(ai).where(eq(ai.aiId, aiId));
+};
+
+interface Props {
+	organizationId: string;
+	aiId: string;
+	input: string;
+	serverId?: string | undefined;
+}
+
+export const suggestVariants = async ({
+	organizationId,
+	aiId,
+	input,
+	serverId,
+}: Props) => {
+	try {
+		const aiSettings = await getAiSettingById(aiId);
+		if (!aiSettings || !aiSettings.isEnabled) {
+			throw new TRPCError({
+				code: "NOT_FOUND",
+				message: "AI features are not enabled for this configuration",
+			});
+		}
+
+		const provider = selectAIProvider(aiSettings);
+		const model = provider(aiSettings.model);
+
+		let ip = "";
+		if (!IS_CLOUD) {
+			const organization = await findOrganizationById(organizationId);
+			ip = organization?.owner.serverIp || "";
+		}
+
+		if (serverId) {
+			const server = await findServerById(serverId);
+			ip = server.ipAddress;
+		} else if (process.env.NODE_ENV === "development") {
+			ip = "127.0.0.1";
+		}
+
+		const { object } = await generateObject({
+			model,
+			output: "array",
+			schema: z.object({
+				id: z.string(),
+				name: z.string(),
+				shortDescription: z.string(),
+				description: z.string(),
+			}),
+			prompt: `
+        Act as advanced DevOps engineer and generate a list of open source projects what can cover users needs(up to 3 items), the suggestion 
+        should include id, name, shortDescription, and description. Use slug of title for id. 
+        
+        Important rules for the response:
+        1. The description field should ONLY contain a plain text description of the project, its features, and use cases
+        2. Do NOT include any code snippets, configuration examples, or installation instructions in the description
+        3. The shortDescription should be a single-line summary focusing on the main technologies
+        
+        User wants to create a new project with the following details, it should be installable in docker and can be docker compose generated for it:
+        
+        ${input}
+      `,
+		});
+
+		if (object?.length) {
+			const result = [];
+			for (const suggestion of object) {
+				try {
+					const { object: docker } = await generateObject({
+						model,
+						output: "object",
+						schema: z.object({
+							dockerCompose: z.string(),
+							envVariables: z.array(
+								z.object({
+									name: z.string(),
+									value: z.string(),
+								}),
+							),
+							domains: z.array(
+								z.object({
+									host: z.string(),
+									port: z.number(),
+									serviceName: z.string(),
+								}),
+							),
+							configFiles: z.array(
+								z.object({
+									content: z.string(),
+									filePath: z.string(),
+								}),
+							),
+						}),
+						prompt: `
+              Act as advanced DevOps engineer and generate docker compose with environment variables and domain configurations needed to install the following project.
+              Return the docker compose as a YAML string and environment variables configuration. Follow these rules:
+
+              Docker Compose Rules:
+              1. Use placeholder like \${VARIABLE_NAME-default} for generated variables in the docker-compose.yml
+              2. Use complex values for passwords/secrets variables
+              3. Don't set container_name field in services
+              4. Don't set version field in the docker compose
+              5. Don't set ports like 'ports: 3000:3000', use 'ports: "3000"' instead
+              6. If a service depends on a database or other service, INCLUDE that service in the docker-compose
+              7. Make sure all required services are defined in the docker-compose
+
+			  Volume Mounting and Configuration Rules:
+              1. DO NOT create configuration files unless the service CANNOT work without them
+              2. Most services can work with just environment variables - USE THEM FIRST
+              3. Ask yourself: "Can this be configured with an environment variable instead?"
+              4. If and ONLY IF a config file is absolutely required:
+                 - Keep it minimal with only critical settings
+                 - Use "../files/" prefix for all mounts
+                 - Format: "../files/folder:/container/path"
+              5. DO NOT add configuration files for:
+                 - Default configurations that work out of the box
+                 - Settings that can be handled by environment variables
+                 - Proxy or routing configurations (these are handled elsewhere)
+
+			  Environment Variables Rules:
+              1. For the envVariables array, provide ACTUAL example values, not placeholders
+              2. Use realistic example values (e.g., "admin@example.com" for emails, "mypassword123" for passwords)
+			  3. DO NOT use \${VARIABLE_NAME-default} syntax in the envVariables values
+              4. ONLY include environment variables that are actually used in the docker-compose
+              5. Every environment variable referenced in the docker-compose MUST have a corresponding entry in envVariables
+              6. Do not include environment variables for services that don't exist in the docker-compose
+                     
+              For each service that needs to be exposed to the internet:
+              1. Define a domain configuration with:
+                - host: the domain name for the service in format: {service-name}-{random-3-chars-hex}-${ip ? ip.replaceAll(".", "-") : ""}.traefik.me
+                - port: the internal port the service runs on
+                - serviceName: the name of the service in the docker-compose
+              2. Make sure the service is properly configured to work with the specified port
+              
+              Project details:
+              ${suggestion?.description}
+            `,
+					});
+					if (!!docker && !!docker.dockerCompose) {
+						result.push({
+							...suggestion,
+							...docker,
+						});
+					}
+				} catch (error) {
+					console.error("Error in docker compose generation:", error);
+				}
+			}
+			return result;
+		}
+
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "No suggestions found",
+		});
+	} catch (error) {
+		console.error("Error in suggestVariants:", error);
+		throw error;
+	}
+};

packages/server/src/services/application.ts

@@ -4,7 +4,6 @@ import {
 	type apiCreateApplication,
 	applications,
 	buildAppName,
-	cleanAppName,
 } from "@dokploy/server/db/schema";
 import { getAdvancedStats } from "@dokploy/server/monitoring/utils";
 import {
@@ -28,7 +27,6 @@ import {
 	getCustomGitCloneCommand,
 } from "@dokploy/server/utils/providers/git";
 import {
-	authGithub,
 	cloneGithubRepository,
 	getGithubCloneCommand,
 } from "@dokploy/server/utils/providers/github";
@@ -40,7 +38,7 @@ import { createTraefikConfig } from "@dokploy/server/utils/traefik/application";
 import { TRPCError } from "@trpc/server";
 import { eq } from "drizzle-orm";
 import { encodeBase64 } from "../utils/docker/utils";
-import { findAdminById, getDokployUrl } from "./admin";
+import { getDokployUrl } from "./admin";
 import {
 	createDeployment,
 	createDeploymentPreview,
@@ -58,7 +56,6 @@ import {
 	updatePreviewDeployment,
 } from "./preview-deployment";
 import { validUniqueServerAppName } from "./project";
-import { cleanupFullDocker } from "./settings";
 export type Application = typeof applications.$inferSelect;
 
 export const createApplication = async (
@@ -185,11 +182,11 @@ export const deployApplication = async ({
 	});
 
 	try {
-		const admin = await findAdminById(application.project.adminId);
+		// const admin = await findUserById(application.project.userId);
 
-		if (admin.cleanupCacheApplications) {
-			await cleanupFullDocker(application?.serverId);
-		}
+		// if (admin.cleanupCacheApplications) {
+		// 	await cleanupFullDocker(application?.serverId);
+		// }
 
 		if (application.sourceType === "github") {
 			await cloneGithubRepository({
@@ -220,7 +217,7 @@ export const deployApplication = async ({
 			applicationName: application.name,
 			applicationType: "application",
 			buildLink,
-			adminId: application.project.adminId,
+			organizationId: application.project.organizationId,
 			domains: application.domains,
 		});
 	} catch (error) {
@@ -233,7 +230,7 @@ export const deployApplication = async ({
 			// @ts-ignore
 			errorMessage: error?.message || "Error building",
 			buildLink,
-			adminId: application.project.adminId,
+			organizationId: application.project.organizationId,
 		});
 
 		throw error;
@@ -260,11 +257,11 @@ export const rebuildApplication = async ({
 	});
 
 	try {
-		const admin = await findAdminById(application.project.adminId);
+		// const admin = await findUserById(application.project.userId);
 
-		if (admin.cleanupCacheApplications) {
-			await cleanupFullDocker(application?.serverId);
-		}
+		// if (admin.cleanupCacheApplications) {
+		// 	await cleanupFullDocker(application?.serverId);
+		// }
 		if (application.sourceType === "github") {
 			await buildApplication(application, deployment.logPath);
 		} else if (application.sourceType === "gitlab") {
@@ -309,11 +306,11 @@ export const deployRemoteApplication = async ({
 
 	try {
 		if (application.serverId) {
-			const admin = await findAdminById(application.project.adminId);
+			// const admin = await findUserById(application.project.userId);
 
-			if (admin.cleanupCacheApplications) {
-				await cleanupFullDocker(application?.serverId);
-			}
+			// if (admin.cleanupCacheApplications) {
+			// 	await cleanupFullDocker(application?.serverId);
+			// }
 			let command = "set -e;";
 			if (application.sourceType === "github") {
 				command += await getGithubCloneCommand({
@@ -352,7 +349,7 @@ export const deployRemoteApplication = async ({
 			applicationName: application.name,
 			applicationType: "application",
 			buildLink,
-			adminId: application.project.adminId,
+			organizationId: application.project.organizationId,
 			domains: application.domains,
 		});
 	} catch (error) {
@@ -376,7 +373,7 @@ export const deployRemoteApplication = async ({
 			// @ts-ignore
 			errorMessage: error?.message || "Error building",
 			buildLink,
-			adminId: application.project.adminId,
+			organizationId: application.project.organizationId,
 		});
 
 		throw error;
@@ -454,11 +451,11 @@ export const deployPreviewApplication = async ({
 		application.env = `${application.previewEnv}\nDOKPLOY_DEPLOY_URL=${previewDeployment?.domain}`;
 		application.buildArgs = application.previewBuildArgs;
 
-		const admin = await findAdminById(application.project.adminId);
+		// const admin = await findUserById(application.project.userId);
 
-		if (admin.cleanupCacheOnPreviews) {
-			await cleanupFullDocker(application?.serverId);
-		}
+		// if (admin.cleanupCacheOnPreviews) {
+		// 	await cleanupFullDocker(application?.serverId);
+		// }
 
 		if (application.sourceType === "github") {
 			await cloneGithubRepository({
@@ -568,11 +565,11 @@ export const deployRemotePreviewApplication = async ({
 		application.buildArgs = application.previewBuildArgs;
 
 		if (application.serverId) {
-			const admin = await findAdminById(application.project.adminId);
+			// const admin = await findUserById(application.project.userId);
 
-			if (admin.cleanupCacheOnPreviews) {
-				await cleanupFullDocker(application?.serverId);
-			}
+			// if (admin.cleanupCacheOnPreviews) {
+			// 	await cleanupFullDocker(application?.serverId);
+			// }
 			let command = "set -e;";
 			if (application.sourceType === "github") {
 				command += await getGithubCloneCommand({
@@ -637,11 +634,11 @@ export const rebuildRemoteApplication = async ({
 
 	try {
 		if (application.serverId) {
-			const admin = await findAdminById(application.project.adminId);
+			// const admin = await findUserById(application.project.userId);
 
-			if (admin.cleanupCacheApplications) {
-				await cleanupFullDocker(application?.serverId);
-			}
+			// if (admin.cleanupCacheApplications) {
+			// 	await cleanupFullDocker(application?.serverId);
+			// }
 			if (application.sourceType !== "docker") {
 				let command = "set -e;";
 				command += getBuildCommand(application, deployment.logPath);

packages/server/src/services/auth.ts

@@ -1,184 +0,0 @@
-import { randomBytes } from "node:crypto";
-import { db } from "@dokploy/server/db";
-import {
-	admins,
-	type apiCreateAdmin,
-	type apiCreateUser,
-	auth,
-	users,
-} from "@dokploy/server/db/schema";
-import { getPublicIpWithFallback } from "@dokploy/server/wss/utils";
-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.toLowerCase(),
-				password: hashedPassword,
-				rol: "admin",
-			})
-			.returning()
-			.then((res) => res[0]);
-
-		if (!newAuth) {
-			throw new TRPCError({
-				code: "BAD_REQUEST",
-				message: "Error creating the user",
-			});
-		}
-
-		await tx
-			.insert(admins)
-			.values({
-				authId: newAuth.id,
-				...(!IS_CLOUD && {
-					serverIp:
-						process.env.ADVERTISE_ADDR || (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 creating 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: "User 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

@@ -2,8 +2,6 @@ import { db } from "@dokploy/server/db";
 import { type apiCreateBackup, backups } from "@dokploy/server/db/schema";
 import { TRPCError } from "@trpc/server";
 import { eq } from "drizzle-orm";
-import { IS_CLOUD } from "../constants";
-import { removeScheduleBackup, scheduleBackup } from "../utils/backups/utils";
 
 export type Backup = typeof backups.$inferSelect;
 

packages/server/src/services/bitbucket.ts

@@ -12,14 +12,14 @@ export type Bitbucket = typeof bitbucket.$inferSelect;
 
 export const createBitbucket = async (
 	input: typeof apiCreateBitbucket._type,
-	adminId: string,
+	organizationId: string,
 ) => {
 	return await db.transaction(async (tx) => {
 		const newGitProvider = await tx
 			.insert(gitProvider)
 			.values({
 				providerType: "bitbucket",
-				adminId: adminId,
+				organizationId: organizationId,
 				name: input.name,
 			})
 			.returning()
@@ -74,12 +74,12 @@ export const updateBitbucket = async (
 			.where(eq(bitbucket.bitbucketId, bitbucketId))
 			.returning();
 
-		if (input.name || input.adminId) {
+		if (input.name || input.organizationId) {
 			await tx
 				.update(gitProvider)
 				.set({
 					name: input.name,
-					adminId: input.adminId,
+					organizationId: input.organizationId,
 				})
 				.where(eq(gitProvider.gitProviderId, input.gitProviderId))
 				.returning();

packages/server/src/services/certificate.ts

@@ -33,13 +33,13 @@ export const findCertificateById = async (certificateId: string) => {
 
 export const createCertificate = async (
 	certificateData: z.infer<typeof apiCreateCertificate>,
-	adminId: string,
+	organizationId: string,
 ) => {
 	const certificate = await db
 		.insert(certificates)
 		.values({
 			...certificateData,
-			adminId: adminId,
+			organizationId: organizationId,
 		})
 		.returning();
 

packages/server/src/services/compose.ts

@@ -44,10 +44,9 @@ import {
 import { TRPCError } from "@trpc/server";
 import { eq } from "drizzle-orm";
 import { encodeBase64 } from "../utils/docker/utils";
-import { findAdminById, getDokployUrl } from "./admin";
+import { getDokployUrl } from "./admin";
 import { createDeploymentCompose, updateDeploymentStatus } from "./deployment";
 import { validUniqueServerAppName } from "./project";
-import { cleanupFullDocker } from "./settings";
 
 export type Compose = typeof compose.$inferSelect;
 
@@ -217,10 +216,10 @@ export const deployCompose = async ({
 	});
 
 	try {
-		const admin = await findAdminById(compose.project.adminId);
-		if (admin.cleanupCacheOnCompose) {
-			await cleanupFullDocker(compose?.serverId);
-		}
+		// const admin = await findUserById(compose.project.userId);
+		// if (admin.cleanupCacheOnCompose) {
+		// 	await cleanupFullDocker(compose?.serverId);
+		// }
 		if (compose.sourceType === "github") {
 			await cloneGithubRepository({
 				...compose,
@@ -247,7 +246,7 @@ export const deployCompose = async ({
 			applicationName: compose.name,
 			applicationType: "compose",
 			buildLink,
-			adminId: compose.project.adminId,
+			organizationId: compose.project.organizationId,
 			domains: compose.domains,
 		});
 	} catch (error) {
@@ -262,7 +261,7 @@ export const deployCompose = async ({
 			// @ts-ignore
 			errorMessage: error?.message || "Error building",
 			buildLink,
-			adminId: compose.project.adminId,
+			organizationId: compose.project.organizationId,
 		});
 		throw error;
 	}
@@ -286,10 +285,10 @@ export const rebuildCompose = async ({
 	});
 
 	try {
-		const admin = await findAdminById(compose.project.adminId);
-		if (admin.cleanupCacheOnCompose) {
-			await cleanupFullDocker(compose?.serverId);
-		}
+		// const admin = await findUserById(compose.project.userId);
+		// if (admin.cleanupCacheOnCompose) {
+		// 	await cleanupFullDocker(compose?.serverId);
+		// }
 		if (compose.serverId) {
 			await getBuildComposeCommand(compose, deployment.logPath);
 		} else {
@@ -332,10 +331,10 @@ export const deployRemoteCompose = async ({
 	});
 	try {
 		if (compose.serverId) {
-			const admin = await findAdminById(compose.project.adminId);
-			if (admin.cleanupCacheOnCompose) {
-				await cleanupFullDocker(compose?.serverId);
-			}
+			// const admin = await findUserById(compose.project.userId);
+			// if (admin.cleanupCacheOnCompose) {
+			// 	await cleanupFullDocker(compose?.serverId);
+			// }
 			let command = "set -e;";
 
 			if (compose.sourceType === "github") {
@@ -381,7 +380,7 @@ export const deployRemoteCompose = async ({
 			applicationName: compose.name,
 			applicationType: "compose",
 			buildLink,
-			adminId: compose.project.adminId,
+			organizationId: compose.project.organizationId,
 			domains: compose.domains,
 		});
 	} catch (error) {
@@ -406,7 +405,7 @@ export const deployRemoteCompose = async ({
 			// @ts-ignore
 			errorMessage: error?.message || "Error building",
 			buildLink,
-			adminId: compose.project.adminId,
+			organizationId: compose.project.organizationId,
 		});
 		throw error;
 	}
@@ -430,10 +429,10 @@ export const rebuildRemoteCompose = async ({
 	});
 
 	try {
-		const admin = await findAdminById(compose.project.adminId);
-		if (admin.cleanupCacheOnCompose) {
-			await cleanupFullDocker(compose?.serverId);
-		}
+		// const admin = await findUserById(compose.project.userId);
+		// if (admin.cleanupCacheOnCompose) {
+		// 	await cleanupFullDocker(compose?.serverId);
+		// }
 		if (compose.serverId) {
 			await getBuildComposeCommand(compose, deployment.logPath);
 		}

packages/server/src/services/deployment.ts

@@ -12,7 +12,7 @@ import {
 import { removeDirectoryIfExistsContent } from "@dokploy/server/utils/filesystem/directory";
 import { TRPCError } from "@trpc/server";
 import { format } from "date-fns";
-import { and, desc, eq, isNull } from "drizzle-orm";
+import { desc, eq } from "drizzle-orm";
 import {
 	type Application,
 	findApplicationById,
@@ -278,9 +278,11 @@ export const removeDeployment = async (deploymentId: string) => {
 			.returning();
 		return deployment[0];
 	} catch (error) {
+		const message =
+			error instanceof Error ? error.message : "Error creating the deployment";
 		throw new TRPCError({
 			code: "BAD_REQUEST",
-			message: "Error deleting this deployment",
+			message,
 		});
 	}
 };
@@ -535,9 +537,11 @@ export const createServerDeployment = async (
 		}
 		return deploymentCreate[0];
 	} catch (error) {
+		const message =
+			error instanceof Error ? error.message : "Error creating the deployment";
 		throw new TRPCError({
 			code: "BAD_REQUEST",
-			message: "Error creating the deployment",
+			message,
 		});
 	}
 };

packages/server/src/services/destination.ts

@@ -10,13 +10,13 @@ export type Destination = typeof destinations.$inferSelect;
 
 export const createDestintation = async (
 	input: typeof apiCreateDestination._type,
-	adminId: string,
+	organizationId: string,
 ) => {
 	const newDestination = await db
 		.insert(destinations)
 		.values({
 			...input,
-			adminId: adminId,
+			organizationId: organizationId,
 		})
 		.returning()
 		.then((value) => value[0]);
@@ -46,14 +46,14 @@ export const findDestinationById = async (destinationId: string) => {
 
 export const removeDestinationById = async (
 	destinationId: string,
-	adminId: string,
+	organizationId: string,
 ) => {
 	const result = await db
 		.delete(destinations)
 		.where(
 			and(
 				eq(destinations.destinationId, destinationId),
-				eq(destinations.adminId, adminId),
+				eq(destinations.organizationId, organizationId),
 			),
 		)
 		.returning();
@@ -73,7 +73,7 @@ export const updateDestinationById = async (
 		.where(
 			and(
 				eq(destinations.destinationId, destinationId),
-				eq(destinations.adminId, destinationData.adminId || ""),
+				eq(destinations.organizationId, destinationData.organizationId || ""),
 			),
 		)
 		.returning();

packages/server/src/services/docker.ts

@@ -98,7 +98,7 @@ export const getConfig = async (
 		const config = JSON.parse(stdout);
 
 		return config;
-	} catch (error) {}
+	} catch (_error) {}
 };
 
 export const getContainersByAppNameMatch = async (
@@ -156,7 +156,7 @@ export const getContainersByAppNameMatch = async (
 		});
 
 		return containers || [];
-	} catch (error) {}
+	} catch (_error) {}
 
 	return [];
 };
@@ -214,7 +214,7 @@ export const getStackContainersByAppName = async (
 		});
 
 		return containers || [];
-	} catch (error) {}
+	} catch (_error) {}
 
 	return [];
 };
@@ -274,7 +274,7 @@ export const getServiceContainersByAppName = async (
 		});
 
 		return containers || [];
-	} catch (error) {}
+	} catch (_error) {}
 
 	return [];
 };
@@ -331,7 +331,7 @@ export const getContainersByAppLabel = async (
 		});
 
 		return containers || [];
-	} catch (error) {}
+	} catch (_error) {}
 
 	return [];
 };
@@ -350,7 +350,7 @@ export const containerRestart = async (containerId: string) => {
 		const config = JSON.parse(stdout);
 
 		return config;
-	} catch (error) {}
+	} catch (_error) {}
 };
 
 export const getSwarmNodes = async (serverId?: string) => {
@@ -379,7 +379,7 @@ export const getSwarmNodes = async (serverId?: string) => {
 			.split("\n")
 			.map((line) => JSON.parse(line));
 		return nodesArray;
-	} catch (error) {}
+	} catch (_error) {}
 };
 
 export const getNodeInfo = async (nodeId: string, serverId?: string) => {
@@ -405,7 +405,7 @@ export const getNodeInfo = async (nodeId: string, serverId?: string) => {
 		const nodeInfo = JSON.parse(stdout);
 
 		return nodeInfo;
-	} catch (error) {}
+	} catch (_error) {}
 };
 
 export const getNodeApplications = async (serverId?: string) => {
@@ -437,7 +437,7 @@ export const getNodeApplications = async (serverId?: string) => {
 			.filter((service) => !service.Name.startsWith("dokploy-"));
 
 		return appArray;
-	} catch (error) {}
+	} catch (_error) {}
 };
 
 export const getApplicationInfo = async (
@@ -470,5 +470,5 @@ export const getApplicationInfo = async (
 			.map((line) => JSON.parse(line));
 
 		return appArray;
-	} catch (error) {}
+	} catch (_error) {}
 };

packages/server/src/services/domain.ts

@@ -4,7 +4,7 @@ import { manageDomain } from "@dokploy/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 { findUserById } from "./admin";
 import { findApplicationById } from "./application";
 import { findServerById } from "./server";
 
@@ -40,7 +40,7 @@ export const createDomain = async (input: typeof apiCreateDomain._type) => {
 
 export const generateTraefikMeDomain = async (
 	appName: string,
-	adminId: string,
+	userId: string,
 	serverId?: string,
 ) => {
 	if (serverId) {
@@ -57,7 +57,7 @@ export const generateTraefikMeDomain = async (
 			projectName: appName,
 		});
 	}
-	const admin = await findAdminById(adminId);
+	const admin = await findUserById(userId);
 	return generateRandomDomain({
 		serverIp: admin?.serverIp || "",
 		projectName: appName,
@@ -126,7 +126,6 @@ export const updateDomainById = async (
 
 export const removeDomainById = async (domainId: string) => {
 	await findDomainById(domainId);
-	// TODO: fix order
 	const result = await db
 		.delete(domains)
 		.where(eq(domains.domainId, domainId))

packages/server/src/services/github.ts

@@ -12,14 +12,14 @@ import { updatePreviewDeployment } from "./preview-deployment";
 export type Github = typeof github.$inferSelect;
 export const createGithub = async (
 	input: typeof apiCreateGithub._type,
-	adminId: string,
+	organizationId: string,
 ) => {
 	return await db.transaction(async (tx) => {
 		const newGitProvider = await tx
 			.insert(gitProvider)
 			.values({
 				providerType: "github",
-				adminId: adminId,
+				organizationId: organizationId,
 				name: input.name,
 			})
 			.returning()
@@ -119,7 +119,7 @@ export const issueCommentExists = async ({
 			comment_id: comment_id,
 		});
 		return true;
-	} catch (error) {
+	} catch (_error) {
 		return false;
 	}
 };

packages/server/src/services/gitlab.ts

@@ -1,9 +1,7 @@
 import { db } from "@dokploy/server/db";
 import {
 	type apiCreateGitlab,
-	type bitbucket,
 	gitProvider,
-	type github,
 	gitlab,
 } from "@dokploy/server/db/schema";
 import { TRPCError } from "@trpc/server";
@@ -13,14 +11,14 @@ export type Gitlab = typeof gitlab.$inferSelect;
 
 export const createGitlab = async (
 	input: typeof apiCreateGitlab._type,
-	adminId: string,
+	organizationId: string,
 ) => {
 	return await db.transaction(async (tx) => {
 		const newGitProvider = await tx
 			.insert(gitProvider)
 			.values({
 				providerType: "gitlab",
-				adminId: adminId,
+				organizationId: organizationId,
 				name: input.name,
 			})
 			.returning()

packages/server/src/services/mariadb.ts

@@ -4,7 +4,7 @@ import {
 	backups,
 	mariadb,
 } from "@dokploy/server/db/schema";
-import { buildAppName, cleanAppName } from "@dokploy/server/db/schema";
+import { buildAppName } from "@dokploy/server/db/schema";
 import { generatePassword } from "@dokploy/server/templates/utils";
 import { buildMariadb } from "@dokploy/server/utils/databases/mariadb";
 import { pullImage } from "@dokploy/server/utils/docker/utils";

packages/server/src/services/mongo.ts

@@ -1,6 +1,6 @@
 import { db } from "@dokploy/server/db";
 import { type apiCreateMongo, backups, mongo } from "@dokploy/server/db/schema";
-import { buildAppName, cleanAppName } from "@dokploy/server/db/schema";
+import { buildAppName } from "@dokploy/server/db/schema";
 import { generatePassword } from "@dokploy/server/templates/utils";
 import { buildMongo } from "@dokploy/server/utils/databases/mongo";
 import { pullImage } from "@dokploy/server/utils/docker/utils";

packages/server/src/services/mount.ts

@@ -123,8 +123,8 @@ export const updateMount = async (
 	mountId: string,
 	mountData: Partial<Mount>,
 ) => {
-	return await db.transaction(async (transaction) => {
-		const mount = await db
+	return await db.transaction(async (tx) => {
+		const mount = await tx
 			.update(mounts)
 			.set({
 				...mountData,
@@ -211,7 +211,7 @@ export const deleteFileMount = async (mountId: string) => {
 		} else {
 			await removeFileOrDirectory(fullPath);
 		}
-	} catch (error) {}
+	} catch (_error) {}
 };
 
 export const getBaseFilesPath = async (mountId: string) => {

packages/server/src/services/notification.ts

@@ -24,7 +24,7 @@ export type Notification = typeof notifications.$inferSelect;
 
 export const createSlackNotification = async (
 	input: typeof apiCreateSlack._type,
-	adminId: string,
+	organizationId: string,
 ) => {
 	await db.transaction(async (tx) => {
 		const newSlack = await tx
@@ -54,7 +54,7 @@ export const createSlackNotification = async (
 				dokployRestart: input.dokployRestart,
 				dockerCleanup: input.dockerCleanup,
 				notificationType: "slack",
-				adminId: adminId,
+				organizationId: organizationId,
 				serverThreshold: input.serverThreshold,
 			})
 			.returning()
@@ -84,7 +84,7 @@ export const updateSlackNotification = async (
 				databaseBackup: input.databaseBackup,
 				dokployRestart: input.dokployRestart,
 				dockerCleanup: input.dockerCleanup,
-				adminId: input.adminId,
+				organizationId: input.organizationId,
 				serverThreshold: input.serverThreshold,
 			})
 			.where(eq(notifications.notificationId, input.notificationId))
@@ -114,7 +114,7 @@ export const updateSlackNotification = async (
 
 export const createTelegramNotification = async (
 	input: typeof apiCreateTelegram._type,
-	adminId: string,
+	organizationId: string,
 ) => {
 	await db.transaction(async (tx) => {
 		const newTelegram = await tx
@@ -122,6 +122,7 @@ export const createTelegramNotification = async (
 			.values({
 				botToken: input.botToken,
 				chatId: input.chatId,
+				messageThreadId: input.messageThreadId,
 			})
 			.returning()
 			.then((value) => value[0]);
@@ -144,7 +145,7 @@ export const createTelegramNotification = async (
 				dokployRestart: input.dokployRestart,
 				dockerCleanup: input.dockerCleanup,
 				notificationType: "telegram",
-				adminId: adminId,
+				organizationId: organizationId,
 				serverThreshold: input.serverThreshold,
 			})
 			.returning()
@@ -174,7 +175,7 @@ export const updateTelegramNotification = async (
 				databaseBackup: input.databaseBackup,
 				dokployRestart: input.dokployRestart,
 				dockerCleanup: input.dockerCleanup,
-				adminId: input.adminId,
+				organizationId: input.organizationId,
 				serverThreshold: input.serverThreshold,
 			})
 			.where(eq(notifications.notificationId, input.notificationId))
@@ -193,6 +194,7 @@ export const updateTelegramNotification = async (
 			.set({
 				botToken: input.botToken,
 				chatId: input.chatId,
+				messageThreadId: input.messageThreadId,
 			})
 			.where(eq(telegram.telegramId, input.telegramId))
 			.returning()
@@ -204,7 +206,7 @@ export const updateTelegramNotification = async (
 
 export const createDiscordNotification = async (
 	input: typeof apiCreateDiscord._type,
-	adminId: string,
+	organizationId: string,
 ) => {
 	await db.transaction(async (tx) => {
 		const newDiscord = await tx
@@ -234,7 +236,7 @@ export const createDiscordNotification = async (
 				dokployRestart: input.dokployRestart,
 				dockerCleanup: input.dockerCleanup,
 				notificationType: "discord",
-				adminId: adminId,
+				organizationId: organizationId,
 				serverThreshold: input.serverThreshold,
 			})
 			.returning()
@@ -264,7 +266,7 @@ export const updateDiscordNotification = async (
 				databaseBackup: input.databaseBackup,
 				dokployRestart: input.dokployRestart,
 				dockerCleanup: input.dockerCleanup,
-				adminId: input.adminId,
+				organizationId: input.organizationId,
 				serverThreshold: input.serverThreshold,
 			})
 			.where(eq(notifications.notificationId, input.notificationId))
@@ -294,7 +296,7 @@ export const updateDiscordNotification = async (
 
 export const createEmailNotification = async (
 	input: typeof apiCreateEmail._type,
-	adminId: string,
+	organizationId: string,
 ) => {
 	await db.transaction(async (tx) => {
 		const newEmail = await tx
@@ -328,7 +330,7 @@ export const createEmailNotification = async (
 				dokployRestart: input.dokployRestart,
 				dockerCleanup: input.dockerCleanup,
 				notificationType: "email",
-				adminId: adminId,
+				organizationId: organizationId,
 				serverThreshold: input.serverThreshold,
 			})
 			.returning()
@@ -358,7 +360,7 @@ export const updateEmailNotification = async (
 				databaseBackup: input.databaseBackup,
 				dokployRestart: input.dokployRestart,
 				dockerCleanup: input.dockerCleanup,
-				adminId: input.adminId,
+				organizationId: input.organizationId,
 				serverThreshold: input.serverThreshold,
 			})
 			.where(eq(notifications.notificationId, input.notificationId))
@@ -392,7 +394,7 @@ export const updateEmailNotification = async (
 
 export const createGotifyNotification = async (
 	input: typeof apiCreateGotify._type,
-	adminId: string,
+	organizationId: string,
 ) => {
 	await db.transaction(async (tx) => {
 		const newGotify = await tx
@@ -424,7 +426,7 @@ export const createGotifyNotification = async (
 				dokployRestart: input.dokployRestart,
 				dockerCleanup: input.dockerCleanup,
 				notificationType: "gotify",
-				adminId: adminId,
+				organizationId: organizationId,
 			})
 			.returning()
 			.then((value) => value[0]);
@@ -453,7 +455,7 @@ export const updateGotifyNotification = async (
 				databaseBackup: input.databaseBackup,
 				dokployRestart: input.dokployRestart,
 				dockerCleanup: input.dockerCleanup,
-				adminId: input.adminId,
+				organizationId: input.organizationId,
 			})
 			.where(eq(notifications.notificationId, input.notificationId))
 			.returning()

packages/server/src/services/postgres.ts

@@ -4,7 +4,7 @@ import {
 	backups,
 	postgres,
 } from "@dokploy/server/db/schema";
-import { buildAppName, cleanAppName } from "@dokploy/server/db/schema";
+import { buildAppName } from "@dokploy/server/db/schema";
 import { generatePassword } from "@dokploy/server/templates/utils";
 import { buildPostgres } from "@dokploy/server/utils/databases/postgres";
 import { pullImage } from "@dokploy/server/utils/docker/utils";

packages/server/src/services/preview-deployment.ts

@@ -2,23 +2,20 @@ import { db } from "@dokploy/server/db";
 import {
 	type apiCreatePreviewDeployment,
 	deployments,
+	organization,
 	previewDeployments,
 } from "@dokploy/server/db/schema";
 import { TRPCError } from "@trpc/server";
 import { and, desc, eq } from "drizzle-orm";
-import { slugify } from "../setup/server-setup";
-import { generatePassword, generateRandomDomain } from "../templates/utils";
+import { generatePassword } from "../templates/utils";
 import { removeService } from "../utils/docker/utils";
 import { removeDirectoryCode } from "../utils/filesystem/directory";
 import { authGithub } from "../utils/providers/github";
 import { removeTraefikConfig } from "../utils/traefik/application";
 import { manageDomain } from "../utils/traefik/domain";
-import { findAdminById } from "./admin";
+import { findUserById } from "./admin";
 import { findApplicationById } from "./application";
-import {
-	removeDeployments,
-	removeDeploymentsByPreviewDeploymentId,
-} from "./deployment";
+import { removeDeploymentsByPreviewDeploymentId } from "./deployment";
 import { createDomain } from "./domain";
 import { type Github, getIssueComment } from "./github";
 
@@ -106,13 +103,17 @@ export const removePreviewDeployment = async (previewDeploymentId: string) => {
 		for (const operation of cleanupOperations) {
 			try {
 				await operation();
-			} catch (error) {}
+			} catch (_error) {}
 		}
 		return deployment[0];
 	} catch (error) {
+		const message =
+			error instanceof Error
+				? error.message
+				: "Error deleting this preview deployment";
 		throw new TRPCError({
 			code: "BAD_REQUEST",
-			message: "Error deleting this preview deployment",
+			message,
 		});
 	}
 };
@@ -154,11 +155,14 @@ export const createPreviewDeployment = async (
 	const application = await findApplicationById(schema.applicationId);
 	const appName = `preview-${application.appName}-${generatePassword(6)}`;
 
+	const org = await db.query.organization.findFirst({
+		where: eq(organization.id, application.project.organizationId),
+	});
 	const generateDomain = await generateWildcardDomain(
 		application.previewWildcard || "*.traefik.me",
 		appName,
 		application.server?.ipAddress || "",
-		application.project.adminId,
+		org?.ownerId || "",
 	);
 
 	const octokit = authGithub(application?.github as Github);
@@ -250,7 +254,7 @@ const generateWildcardDomain = async (
 	baseDomain: string,
 	appName: string,
 	serverIp: string,
-	adminId: string,
+	userId: string,
 ): Promise<string> => {
 	if (!baseDomain.startsWith("*.")) {
 		throw new Error('The base domain must start with "*."');
@@ -268,7 +272,7 @@ const generateWildcardDomain = async (
 		}
 
 		if (!ip) {
-			const admin = await findAdminById(adminId);
+			const admin = await findUserById(userId);
 			ip = admin?.serverIp || "";
 		}
 

packages/server/src/services/project.ts

@@ -16,13 +16,13 @@ export type Project = typeof projects.$inferSelect;
 
 export const createProject = async (
 	input: typeof apiCreateProject._type,
-	adminId: string,
+	organizationId: string,
 ) => {
 	const newProject = await db
 		.insert(projects)
 		.values({
 			...input,
-			adminId: adminId,
+			organizationId: organizationId,
 		})
 		.returning()
 		.then((value) => value[0]);

packages/server/src/services/redirect.ts

@@ -6,7 +6,7 @@ import {
 	updateRedirectMiddleware,
 } from "@dokploy/server/utils/traefik/redirect";
 import { TRPCError } from "@trpc/server";
-import { desc, eq } from "drizzle-orm";
+import { eq } from "drizzle-orm";
 import type { z } from "zod";
 import { findApplicationById } from "./application";
 export type Redirect = typeof redirects.$inferSelect;
@@ -114,9 +114,11 @@ export const updateRedirectById = async (
 
 		return redirect;
 	} catch (error) {
+		const message =
+			error instanceof Error ? error.message : "Error updating this redirect";
 		throw new TRPCError({
 			code: "BAD_REQUEST",
-			message: "Error updating this redirect",
+			message,
 		});
 	}
 };

packages/server/src/services/redis.ts

@@ -1,6 +1,6 @@
 import { db } from "@dokploy/server/db";
 import { type apiCreateRedis, redis } from "@dokploy/server/db/schema";
-import { buildAppName, cleanAppName } from "@dokploy/server/db/schema";
+import { buildAppName } from "@dokploy/server/db/schema";
 import { generatePassword } from "@dokploy/server/templates/utils";
 import { buildRedis } from "@dokploy/server/utils/databases/redis";
 import { pullImage } from "@dokploy/server/utils/docker/utils";

packages/server/src/services/registry.ts

@@ -12,14 +12,14 @@ export type Registry = typeof registry.$inferSelect;
 
 export const createRegistry = async (
 	input: typeof apiCreateRegistry._type,
-	adminId: string,
+	organizationId: string,
 ) => {
 	return await db.transaction(async (tx) => {
 		const newRegistry = await tx
 			.insert(registry)
 			.values({
 				...input,
-				adminId: adminId,
+				organizationId: organizationId,
 			})
 			.returning()
 			.then((value) => value[0]);
@@ -112,9 +112,11 @@ export const updateRegistry = async (
 
 		return response;
 	} catch (error) {
+		const message =
+			error instanceof Error ? error.message : "Error updating this registry";
 		throw new TRPCError({
 			code: "BAD_REQUEST",
-			message: "Error updating this registry",
+			message,
 		});
 	}
 };
@@ -135,9 +137,11 @@ export const findRegistryById = async (registryId: string) => {
 	return registryResponse;
 };
 
-export const findAllRegistryByAdminId = async (adminId: string) => {
+export const findAllRegistryByOrganizationId = async (
+	organizationId: string,
+) => {
 	const registryResponse = await db.query.registry.findMany({
-		where: eq(registry.adminId, adminId),
+		where: eq(registry.organizationId, organizationId),
 	});
 	return registryResponse;
 };

packages/server/src/services/security.ts

@@ -76,9 +76,11 @@ export const deleteSecurityById = async (securityId: string) => {
 		await removeSecurityMiddleware(application, result);
 		return result;
 	} catch (error) {
+		const message =
+			error instanceof Error ? error.message : "Error removing this security";
 		throw new TRPCError({
 			code: "BAD_REQUEST",
-			message: "Error removing this security",
+			message,
 		});
 	}
 };
@@ -98,9 +100,11 @@ export const updateSecurityById = async (
 
 		return response[0];
 	} catch (error) {
+		const message =
+			error instanceof Error ? error.message : "Error updating this security";
 		throw new TRPCError({
 			code: "BAD_REQUEST",
-			message: "Error updating this security",
+			message,
 		});
 	}
 };

packages/server/src/services/server.ts

@@ -1,19 +1,24 @@
 import { db } from "@dokploy/server/db";
-import { type apiCreateServer, server } from "@dokploy/server/db/schema";
+import {
+	type apiCreateServer,
+	organization,
+	server,
+} from "@dokploy/server/db/schema";
 import { TRPCError } from "@trpc/server";
-import { desc, eq } from "drizzle-orm";
+import { eq } from "drizzle-orm";
 
 export type Server = typeof server.$inferSelect;
 
 export const createServer = async (
 	input: typeof apiCreateServer._type,
-	adminId: string,
+	organizationId: string,
 ) => {
 	const newServer = await db
 		.insert(server)
 		.values({
 			...input,
-			adminId: adminId,
+			organizationId: organizationId,
+			createdAt: new Date().toISOString(),
 		})
 		.returning()
 		.then((value) => value[0]);
@@ -45,12 +50,16 @@ export const findServerById = async (serverId: string) => {
 	return currentServer;
 };
 
-export const findServersByAdminId = async (adminId: string) => {
-	const servers = await db.query.server.findMany({
-		where: eq(server.adminId, adminId),
-		orderBy: desc(server.createdAt),
+export const findServersByUserId = async (userId: string) => {
+	const orgs = await db.query.organization.findMany({
+		where: eq(organization.ownerId, userId),
+		with: {
+			servers: true,
+		},
 	});
 
+	const servers = orgs.flatMap((org) => org.servers);
+
 	return servers;
 };
 

packages/server/src/services/settings.ts

@@ -5,8 +5,6 @@ import {
 	execAsync,
 	execAsyncRemote,
 } from "@dokploy/server/utils/process/execAsync";
-import { findAdminById } from "./admin";
-// import packageInfo from "../../../package.json";
 
 export interface IUpdateData {
 	latestVersion: string | null;
@@ -171,7 +169,6 @@ echo "$json_output"
 		const result = JSON.parse(stdout);
 		return result;
 	}
-	const items = readdirSync(dirPath, { withFileTypes: true });
 
 	const stack = [dirPath];
 	const result: TreeDataItem[] = [];

packages/server/src/services/user.ts

@@ -1,80 +1,53 @@
 import { db } from "@dokploy/server/db";
-import { users } from "@dokploy/server/db/schema";
+import { apikey, member, users_temp } from "@dokploy/server/db/schema";
 import { TRPCError } from "@trpc/server";
-import { eq } from "drizzle-orm";
+import { and, eq } from "drizzle-orm";
+import { auth } from "../lib/auth";
 
-export type User = typeof users.$inferSelect;
+export type User = typeof users_temp.$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);
+export const addNewProject = async (
+	userId: string,
+	projectId: string,
+	organizationId: string,
+) => {
+	const userR = await findMemberById(userId, organizationId);
 
 	await db
-		.update(users)
+		.update(member)
 		.set({
-			accessedProjects: [...user.accessedProjects, projectId],
+			accessedProjects: [...userR.accessedProjects, projectId],
 		})
-		.where(eq(users.authId, authId));
+		.where(
+			and(eq(member.id, userR.id), eq(member.organizationId, organizationId)),
+		);
 };
 
-export const addNewService = async (authId: string, serviceId: string) => {
-	const user = await findUserByAuthId(authId);
+export const addNewService = async (
+	userId: string,
+	serviceId: string,
+	organizationId: string,
+) => {
+	const userR = await findMemberById(userId, organizationId);
 	await db
-		.update(users)
+		.update(member)
 		.set({
-			accessedServices: [...user.accessedServices, serviceId],
+			accessedServices: [...userR.accessedServices, serviceId],
 		})
-		.where(eq(users.authId, authId));
+		.where(
+			and(eq(member.id, userR.id), eq(member.organizationId, organizationId)),
+		);
 };
 
 export const canPerformCreationService = async (
 	userId: string,
 	projectId: string,
+	organizationId: string,
 ) => {
-	const { accessedProjects, canCreateServices } =
-		await findUserByAuthId(userId);
+	const { accessedProjects, canCreateServices } = await findMemberById(
+		userId,
+		organizationId,
+	);
 	const haveAccessToProject = accessedProjects.includes(projectId);
 
 	if (canCreateServices && haveAccessToProject) {
@@ -87,8 +60,9 @@ export const canPerformCreationService = async (
 export const canPerformAccessService = async (
 	userId: string,
 	serviceId: string,
+	organizationId: string,
 ) => {
-	const { accessedServices } = await findUserByAuthId(userId);
+	const { accessedServices } = await findMemberById(userId, organizationId);
 	const haveAccessToService = accessedServices.includes(serviceId);
 
 	if (haveAccessToService) {
@@ -99,11 +73,14 @@ export const canPerformAccessService = async (
 };
 
 export const canPeformDeleteService = async (
-	authId: string,
+	userId: string,
 	serviceId: string,
+	organizationId: string,
 ) => {
-	const { accessedServices, canDeleteServices } =
-		await findUserByAuthId(authId);
+	const { accessedServices, canDeleteServices } = await findMemberById(
+		userId,
+		organizationId,
+	);
 	const haveAccessToService = accessedServices.includes(serviceId);
 
 	if (canDeleteServices && haveAccessToService) {
@@ -113,8 +90,11 @@ export const canPeformDeleteService = async (
 	return false;
 };
 
-export const canPerformCreationProject = async (authId: string) => {
-	const { canCreateProjects } = await findUserByAuthId(authId);
+export const canPerformCreationProject = async (
+	userId: string,
+	organizationId: string,
+) => {
+	const { canCreateProjects } = await findMemberById(userId, organizationId);
 
 	if (canCreateProjects) {
 		return true;
@@ -123,8 +103,11 @@ export const canPerformCreationProject = async (authId: string) => {
 	return false;
 };
 
-export const canPerformDeleteProject = async (authId: string) => {
-	const { canDeleteProjects } = await findUserByAuthId(authId);
+export const canPerformDeleteProject = async (
+	userId: string,
+	organizationId: string,
+) => {
+	const { canDeleteProjects } = await findMemberById(userId, organizationId);
 
 	if (canDeleteProjects) {
 		return true;
@@ -134,10 +117,11 @@ export const canPerformDeleteProject = async (authId: string) => {
 };
 
 export const canPerformAccessProject = async (
-	authId: string,
+	userId: string,
 	projectId: string,
+	organizationId: string,
 ) => {
-	const { accessedProjects } = await findUserByAuthId(authId);
+	const { accessedProjects } = await findMemberById(userId, organizationId);
 
 	const haveAccessToProject = accessedProjects.includes(projectId);
 
@@ -147,26 +131,45 @@ export const canPerformAccessProject = async (
 	return false;
 };
 
-export const canAccessToTraefikFiles = async (authId: string) => {
-	const { canAccessToTraefikFiles } = await findUserByAuthId(authId);
+export const canAccessToTraefikFiles = async (
+	userId: string,
+	organizationId: string,
+) => {
+	const { canAccessToTraefikFiles } = await findMemberById(
+		userId,
+		organizationId,
+	);
 	return canAccessToTraefikFiles;
 };
 
 export const checkServiceAccess = async (
-	authId: string,
+	userId: string,
 	serviceId: string,
+	organizationId: string,
 	action = "access" as "access" | "create" | "delete",
 ) => {
 	let hasPermission = false;
 	switch (action) {
 		case "create":
-			hasPermission = await canPerformCreationService(authId, serviceId);
+			hasPermission = await canPerformCreationService(
+				userId,
+				serviceId,
+				organizationId,
+			);
 			break;
 		case "access":
-			hasPermission = await canPerformAccessService(authId, serviceId);
+			hasPermission = await canPerformAccessService(
+				userId,
+				serviceId,
+				organizationId,
+			);
 			break;
 		case "delete":
-			hasPermission = await canPeformDeleteService(authId, serviceId);
+			hasPermission = await canPeformDeleteService(
+				userId,
+				serviceId,
+				organizationId,
+			);
 			break;
 		default:
 			hasPermission = false;
@@ -182,6 +185,7 @@ export const checkServiceAccess = async (
 export const checkProjectAccess = async (
 	authId: string,
 	action: "create" | "delete" | "access",
+	organizationId: string,
 	projectId?: string,
 ) => {
 	let hasPermission = false;
@@ -190,13 +194,14 @@ export const checkProjectAccess = async (
 			hasPermission = await canPerformAccessProject(
 				authId,
 				projectId as string,
+				organizationId,
 			);
 			break;
 		case "create":
-			hasPermission = await canPerformCreationProject(authId);
+			hasPermission = await canPerformCreationProject(authId, organizationId);
 			break;
 		case "delete":
-			hasPermission = await canPerformDeleteProject(authId);
+			hasPermission = await canPerformDeleteProject(authId, organizationId);
 			break;
 		default:
 			hasPermission = false;
@@ -208,3 +213,82 @@ export const checkProjectAccess = async (
 		});
 	}
 };
+
+export const findMemberById = async (
+	userId: string,
+	organizationId: string,
+) => {
+	const result = await db.query.member.findFirst({
+		where: and(
+			eq(member.userId, userId),
+			eq(member.organizationId, organizationId),
+		),
+		with: {
+			user: true,
+		},
+	});
+
+	if (!result) {
+		throw new TRPCError({
+			code: "UNAUTHORIZED",
+			message: "Permission denied",
+		});
+	}
+	return result;
+};
+
+export const updateUser = async (userId: string, userData: Partial<User>) => {
+	const user = await db
+		.update(users_temp)
+		.set({
+			...userData,
+		})
+		.where(eq(users_temp.id, userId))
+		.returning()
+		.then((res) => res[0]);
+
+	return user;
+};
+
+export const createApiKey = async (
+	userId: string,
+	input: {
+		name: string;
+		prefix?: string;
+		expiresIn?: number;
+		metadata: {
+			organizationId: string;
+		};
+		rateLimitEnabled?: boolean;
+		rateLimitTimeWindow?: number;
+		rateLimitMax?: number;
+		remaining?: number;
+		refillAmount?: number;
+		refillInterval?: number;
+	},
+) => {
+	const apiKey = await auth.createApiKey({
+		body: {
+			name: input.name,
+			expiresIn: input.expiresIn,
+			prefix: input.prefix,
+			rateLimitEnabled: input.rateLimitEnabled,
+			rateLimitTimeWindow: input.rateLimitTimeWindow,
+			rateLimitMax: input.rateLimitMax,
+			remaining: input.remaining,
+			refillAmount: input.refillAmount,
+			refillInterval: input.refillInterval,
+			userId,
+		},
+	});
+
+	if (input.metadata) {
+		await db
+			.update(apikey)
+			.set({
+				metadata: JSON.stringify(input.metadata),
+			})
+			.where(eq(apikey.id, apiKey.id));
+	}
+	return apiKey;
+};