Merge branch 'canary' into 560-self-hosted-gitlab

apps/dokploy/server/api/root.ts

@@ -31,6 +31,7 @@ import { settingsRouter } from "./routers/settings";
 import { sshRouter } from "./routers/ssh-key";
 import { stripeRouter } from "./routers/stripe";
 import { userRouter } from "./routers/user";
+import { previewDeploymentRouter } from "./routers/preview-deployment";
 
 /**
  * This is the primary router for your server.
@@ -55,6 +56,7 @@ export const appRouter = createTRPCRouter({
 	destination: destinationRouter,
 	backup: backupRouter,
 	deployment: deploymentRouter,
+	previewDeployment: previewDeploymentRouter,
 	mounts: mountRouter,
 	certificates: certificateRouter,
 	settings: settingsRouter,

apps/dokploy/server/api/routers/domain.ts

@@ -13,6 +13,7 @@ import {
 	findDomainById,
 	findDomainsByApplicationId,
 	findDomainsByComposeId,
+	findPreviewDeploymentById,
 	generateTraefikMeDomain,
 	manageDomain,
 	removeDomain,
@@ -108,12 +109,33 @@ export const domainRouter = createTRPCRouter({
 						message: "You are not authorized to access this compose",
 					});
 				}
+			} else if (currentDomain.previewDeploymentId) {
+				const newPreviewDeployment = await findPreviewDeploymentById(
+					currentDomain.previewDeploymentId,
+				);
+				if (
+					newPreviewDeployment.application.project.adminId !== ctx.user.adminId
+				) {
+					throw new TRPCError({
+						code: "UNAUTHORIZED",
+						message: "You are not authorized to access this preview deployment",
+					});
+				}
 			}
 			const result = await updateDomainById(input.domainId, input);
 			const domain = await findDomainById(input.domainId);
 			if (domain.applicationId) {
 				const application = await findApplicationById(domain.applicationId);
 				await manageDomain(application, domain);
+			} else if (domain.previewDeploymentId) {
+				const previewDeployment = await findPreviewDeploymentById(
+					domain.previewDeploymentId,
+				);
+				const application = await findApplicationById(
+					previewDeployment.applicationId,
+				);
+				application.appName = previewDeployment.appName;
+				await manageDomain(application, domain);
 			}
 			return result;
 		}),

apps/dokploy/server/api/routers/preview-deployment.ts

@@ -0,0 +1,54 @@
+import { apiFindAllByApplication } from "@/server/db/schema";
+import {
+	findApplicationById,
+	findPreviewDeploymentById,
+	findPreviewDeploymentsByApplicationId,
+	removePreviewDeployment,
+} from "@dokploy/server";
+import { TRPCError } from "@trpc/server";
+import { z } from "zod";
+import { createTRPCRouter, protectedProcedure } from "../trpc";
+
+export const previewDeploymentRouter = createTRPCRouter({
+	all: protectedProcedure
+		.input(apiFindAllByApplication)
+		.query(async ({ input, ctx }) => {
+			const application = await findApplicationById(input.applicationId);
+			if (application.project.adminId !== ctx.user.adminId) {
+				throw new TRPCError({
+					code: "UNAUTHORIZED",
+					message: "You are not authorized to access this application",
+				});
+			}
+			return await findPreviewDeploymentsByApplicationId(input.applicationId);
+		}),
+	delete: protectedProcedure
+		.input(z.object({ previewDeploymentId: z.string() }))
+		.mutation(async ({ input, ctx }) => {
+			const previewDeployment = await findPreviewDeploymentById(
+				input.previewDeploymentId,
+			);
+			if (previewDeployment.application.project.adminId !== ctx.user.adminId) {
+				throw new TRPCError({
+					code: "UNAUTHORIZED",
+					message: "You are not authorized to delete this preview deployment",
+				});
+			}
+			await removePreviewDeployment(input.previewDeploymentId);
+			return true;
+		}),
+	one: protectedProcedure
+		.input(z.object({ previewDeploymentId: z.string() }))
+		.query(async ({ input, ctx }) => {
+			const previewDeployment = await findPreviewDeploymentById(
+				input.previewDeploymentId,
+			);
+			if (previewDeployment.application.project.adminId !== ctx.user.adminId) {
+				throw new TRPCError({
+					code: "UNAUTHORIZED",
+					message: "You are not authorized to access this preview deployment",
+				});
+			}
+			return previewDeployment;
+		}),
+});

apps/dokploy/server/api/routers/server.ts

@@ -26,6 +26,7 @@ import {
 	haveActiveServices,
 	removeDeploymentsByServerId,
 	serverSetup,
+	serverValidate,
 	updateServerById,
 } from "@dokploy/server";
 import { TRPCError } from "@trpc/server";
@@ -118,6 +119,47 @@ export const serverRouter = createTRPCRouter({
 				throw error;
 			}
 		}),
+	validate: protectedProcedure
+		.input(apiFindOneServer)
+		.query(async ({ input, ctx }) => {
+			try {
+				const server = await findServerById(input.serverId);
+				if (server.adminId !== ctx.user.adminId) {
+					throw new TRPCError({
+						code: "UNAUTHORIZED",
+						message: "You are not authorized to validate this server",
+					});
+				}
+				const response = await serverValidate(input.serverId);
+				return response as unknown as {
+					docker: {
+						enabled: boolean;
+						version: string;
+					};
+					rclone: {
+						enabled: boolean;
+						version: string;
+					};
+					nixpacks: {
+						enabled: boolean;
+						version: string;
+					};
+					buildpacks: {
+						enabled: boolean;
+						version: string;
+					};
+					isDokployNetworkInstalled: boolean;
+					isSwarmInstalled: boolean;
+					isMainDirectoryInstalled: boolean;
+				};
+			} catch (error) {
+				throw new TRPCError({
+					code: "BAD_REQUEST",
+					message: error instanceof Error ? error?.message : `Error: ${error}`,
+					cause: error as Error,
+				});
+			}
+		}),
 	remove: protectedProcedure
 		.input(apiRemoveServer)
 		.mutation(async ({ input, ctx }) => {

apps/dokploy/server/queues/deployments-queue.ts

@@ -1,14 +1,17 @@
 import {
 	deployApplication,
 	deployCompose,
+	deployPreviewApplication,
 	deployRemoteApplication,
 	deployRemoteCompose,
+	deployRemotePreviewApplication,
 	rebuildApplication,
 	rebuildCompose,
 	rebuildRemoteApplication,
 	rebuildRemoteCompose,
 	updateApplicationStatus,
 	updateCompose,
+	updatePreviewDeployment,
 } from "@dokploy/server";
 import { type Job, Worker } from "bullmq";
 import type { DeploymentJob } from "./queue-types";
@@ -20,6 +23,7 @@ export const deploymentWorker = new Worker(
 		try {
 			if (job.data.applicationType === "application") {
 				await updateApplicationStatus(job.data.applicationId, "running");
+
 				if (job.data.server) {
 					if (job.data.type === "redeploy") {
 						await rebuildRemoteApplication({
@@ -83,6 +87,29 @@ export const deploymentWorker = new Worker(
 						});
 					}
 				}
+			} else if (job.data.applicationType === "application-preview") {
+				await updatePreviewDeployment(job.data.previewDeploymentId, {
+					previewStatus: "running",
+				});
+				if (job.data.server) {
+					if (job.data.type === "deploy") {
+						await deployRemotePreviewApplication({
+							applicationId: job.data.applicationId,
+							titleLog: job.data.titleLog,
+							descriptionLog: job.data.descriptionLog,
+							previewDeploymentId: job.data.previewDeploymentId,
+						});
+					}
+				} else {
+					if (job.data.type === "deploy") {
+						await deployPreviewApplication({
+							applicationId: job.data.applicationId,
+							titleLog: job.data.titleLog,
+							descriptionLog: job.data.descriptionLog,
+							previewDeploymentId: job.data.previewDeploymentId,
+						});
+					}
+				}
 			}
 		} catch (error) {
 			console.log("Error", error);

apps/dokploy/server/queues/queue-types.ts

@@ -16,6 +16,16 @@ type DeployJob =
 			type: "deploy" | "redeploy";
 			applicationType: "compose";
 			serverId?: string;
+	  }
+	| {
+			applicationId: string;
+			titleLog: string;
+			descriptionLog: string;
+			server?: boolean;
+			type: "deploy";
+			applicationType: "application-preview";
+			previewDeploymentId: string;
+			serverId?: string;
 	  };
 
 export type DeploymentJob = DeployJob;

apps/dokploy/server/server.ts

@@ -24,7 +24,7 @@ import { setupTerminalWebSocketServer } from "./wss/terminal";
 config({ path: ".env" });
 const PORT = Number.parseInt(process.env.PORT || "3000", 10);
 const dev = process.env.NODE_ENV !== "production";
-const app = next({ dev, turbopack: dev });
+const app = next({ dev, turbopack: process.env.TURBOPACK === "1" });
 const handle = app.getRequestHandler();
 void app.prepare().then(async () => {
 	try {