Feature | Redirection

prisma/migrations/20250409071302_add_redirect_url/migration.sql

@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "Domains" ADD COLUMN "redirectUrl" TEXT;

prisma/schema.prisma

@@ -21,6 +21,7 @@ model Domains {
   port               Int
   isLocked           Boolean  @default(false)
   enableHttps        Boolean  @default(true)
+  redirectUrl        String?
   createdAt          DateTime @default(now())
 }
 

src/app/api/_services/caddy/caddy-templates.ts

@@ -105,3 +105,38 @@ export const getRouteHandlerTemplate = (
 		]
 	};
 };
+
+export const getRedirectTemplate = (
+	fromDomain: string,
+	toDomain: string,
+	enableHttps = true,
+): RouteConfig => {
+	const protocol = enableHttps ? "https" : "http";
+	const routeConfig: RouteConfig = {
+		match: [
+			{
+				host: [fromDomain],
+			},
+		],
+		handle: [
+			{
+				handler: "subroute",
+				routes: [
+					{
+						handle: [
+							{
+								handler: "static_response",
+								headers: {
+									Location: [`${protocol}://${toDomain}{http.request.uri}`],
+								},
+								status_code: 301,
+							},
+						],
+					},
+				],
+			},
+		],
+	};
+
+	return routeConfig;
+};

src/app/api/_services/caddy/template-types.ts

@@ -28,18 +28,20 @@ export type RouteHandlerConfig = {
 }
 
 export type HandlerConfig = {
-	handler: "reverse_proxy";
-	upstreams: { dial: string }[];
+	handler: "reverse_proxy" | "static_response";
+	upstreams?: { dial: string }[];
 	headers: {
-		request: {
+		request?: {
 			set: {
 				Host: string[];
 				"X-Origin-Host": string[];
 				"X-Origin-IP": string[];
 			};
 		};
+		Location?: string[];
 	};
-	transport: {
+	status_code?: number
+	transport?: {
 		protocol: string;
 		// eslint-disable-next-line @typescript-eslint/no-explicit-any
 		tls?: Record<string, any>;

src/app/api/domain/add/route.ts

@@ -5,7 +5,7 @@ import {
   loadCaddyConfig,
   validateIncomingDomain,
 } from "../../_services/caddy/caddy-service";
-import { getRouteTemplate } from "../../_services/caddy/caddy-templates";
+import { getRouteTemplate, getRedirectTemplate } from "../../_services/caddy/caddy-templates";
 import prisma from "../../../../lib/prisma";
 import { Prisma } from "@prisma/client";
 import { getUserFromHeader, hasPermission } from "../../_services/user/user-service";
@@ -22,7 +22,6 @@ export async function POST(request: NextRequest) {
       );
     }
 
-    // Check if user has permission to add domains (requires proxies:manage or proxies:modify)
     if (!hasPermission(user, "proxies:manage") && !hasPermission(user, "proxies:modify")) {
       return NextResponse.json(
         { error: "Forbidden - Insufficient permissions" },
@@ -33,46 +32,101 @@ export async function POST(request: NextRequest) {
     const reqBody = await request.json();
     const reqPayload = addDomainSchema.parse(reqBody);
 
+    // Check if the domain is already registered
     const { currentConfig, hasExistingRoute } = await validateIncomingDomain(
-      reqPayload.incomingAddress
+      reqPayload.domain
     );
-
+    
     if (hasExistingRoute) {
       return NextResponse.json(
-        { error: "Domain already registered" },
+        { error: `Domain ${reqPayload.domain} is already registered` },
         { status: 409 }
       );
     }
 
-    const parsedPort = Number(reqPayload.port);
-
-    const routeConfig = getRouteTemplate(
-      reqPayload.incomingAddress,
-      reqPayload.destinationAddress,
-      parsedPort,
-      reqPayload.enableHttps
-    );
+    if (!currentConfig) {
+      return NextResponse.json(
+        { error: "Failed to retrieve Caddy config" },
+        { status: 500 }
+      );
+    }
 
+    const parsedPort = reqPayload.port === "" ? null : Number(reqPayload.port);
     const newConfigPayload = { ...currentConfig };
-    newConfigPayload.apps.http.servers.main.routes.push(routeConfig);
-
-
+
     await prisma.$transaction(async (tx: Prisma.TransactionClient) => {
+      // Create a new Caddy configuration
       await tx.caddyConfiguration.create({
         data: {
           config: JSON.parse(JSON.stringify(newConfigPayload)),
         },
       });
-      await tx.domains.create({
-        data: {
-          incomingAddress: reqPayload.incomingAddress,
-          destinationAddress: reqPayload.destinationAddress,
-          port: parsedPort,
-          enableHttps: reqPayload.enableHttps
-        },
+
+      // Check if domain already exists in database
+      const existingDomain = await tx.domains.findUnique({
+        where: { incomingAddress: reqPayload.domain }
       });
+
+      if (existingDomain) {
+        console.log(`Domain ${reqPayload.domain} already exists in database, updating...`);
+
+        // Update the existing domain
+        await tx.domains.update({
+          where: { incomingAddress: reqPayload.domain },
+          data: {
+            destinationAddress: reqPayload.enableRedirection && reqPayload.redirectTo ? 
+              reqPayload.redirectTo.trim() : reqPayload.destinationAddress,
+            port: parsedPort ?? undefined,
+            enableHttps: reqPayload.enableHttps,
+            redirectUrl: reqPayload.enableRedirection && reqPayload.redirectTo ? 
+              reqPayload.redirectTo.trim() : null,
+          }
+        });
+      } else {
+        // Add new domain configuration based on whether redirection is enabled
+        if (reqPayload.enableRedirection && reqPayload.redirectTo && reqPayload.redirectTo.trim()) {
+          const redirectConfig = getRedirectTemplate(
+            reqPayload.domain,
+            reqPayload.redirectTo,
+            reqPayload.enableHttps
+          );
+          newConfigPayload.apps.http.servers.main.routes.push(redirectConfig);
+
+          // Save domain in database with redirection info
+          await tx.domains.create({
+            data: {
+              incomingAddress: reqPayload.domain,
+              destinationAddress: reqPayload.redirectTo.trim(),
+              port: parsedPort || 0,
+              enableHttps: reqPayload.enableHttps,
+              redirectUrl: reqPayload.redirectTo.trim() // Store redirection info
+            }
+          });
+        } else {
+          // Create a normal proxy route
+          const routeConfig = getRouteTemplate(
+            reqPayload.domain,
+            reqPayload.destinationAddress,
+            parsedPort ?? 80,
+            reqPayload.enableHttps
+          );
+          newConfigPayload.apps.http.servers.main.routes.push(routeConfig);
+
+          // Save domain in database without redirection info
+          await tx.domains.create({
+            data: {
+              incomingAddress: reqPayload.domain,
+              destinationAddress: reqPayload.destinationAddress,
+              port: parsedPort || 0,
+              enableHttps: reqPayload.enableHttps,
+              redirectUrl: null // No redirection
+            }
+          });
+        }
+      }
     });
 
+    console.log("New Caddy configuration updated");
     await loadCaddyConfig(newConfigPayload);
 
     return NextResponse.json(
@@ -81,16 +135,17 @@ export async function POST(request: NextRequest) {
       },
       { status: 201 }
     );
-  } catch (err) {
-    if (err instanceof z.ZodError) {
+  } catch (error) {
+    if (error instanceof z.ZodError) {
       return NextResponse.json(
         {
           error: "Validation Failed",
-          details: err.errors,
+          details: error.errors,
         },
         { status: 400 }
       );
     }
+    console.error("error...", error)
     return NextResponse.json(
       { error: "Failed to add domain" },
       { status: 500 }

src/app/api/domain/domain-schema.ts

@@ -1,27 +1,61 @@
 import { z } from "zod";
 
-const domainRegex = /^[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
+// Updated regex to accept localhost and other local development domains
+const domainRegex = /^[a-zA-Z0-9.-]+\.[a-zA-Z0-9]{1,}$/;
 
 const domainOrIpOrDockerRegex =
-  /^(?:[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}|\b\d{1,3}(\.\d{1,3}){3}\b|\[?[a-fA-F0-9:]+\]?|[a-zA-Z0-9_-]+)$/;
+  /^(?:[a-zA-Z0-9.-]+\.[a-zA-Z0-9]{1,}|\b\d{1,3}(\.\d{1,3}){3}\b|\[?[a-fA-F0-9:]+\]?|[a-zA-Z0-9_-]+)$/;
 
 export const addDomainSchema = z.object({
-  incomingAddress: z
+  domain: z
     .string()
-    .min(1, "Incoming address is required")
+    .min(1, "Domain is required")
     .refine((value) => domainRegex.test(value), {
       message:
         "Invalid domain format (must be a plain domain, e.g., example.com)",
     }),
+  enableRedirection: z.boolean().default(false),
+  redirectTo: z.string().optional(),
   destinationAddress: z
-    .string()
-    .min(1, "Destination address is required")
-    .refine((value) => domainOrIpOrDockerRegex.test(value), {
-      message:
-        "Invalid address format (must be a domain, IP, service name etc.)",
-    }),
-  port: z.string().min(1, "Port is required"),
+    .string(),
+  port: z.string(),
   enableHttps: z.boolean().default(true),
+}).superRefine((data, ctx) => {
+  const issues = [];
+
+  if (data.enableRedirection && data.redirectTo) {
+    if (!domainRegex.test(data.redirectTo.trim())) {
+      ctx.addIssue({
+        path: ["redirectTo"],
+        message: "Invalid redirect domain format",
+        code: z.ZodIssueCode.custom,
+      });
+      issues.push("redirectTo");
+    }
+  }
+
+  if (!data.enableRedirection) {
+    const portNumber = parseInt(data.port, 10);
+    if (isNaN(portNumber) || portNumber < 1 || portNumber > 65535) {
+      ctx.addIssue({
+        path: ["port"], 
+        message: "Invalid port number",
+        code: z.ZodIssueCode.custom,
+      });
+      issues.push("port");
+    }
+
+    if (!domainOrIpOrDockerRegex.test(data.destinationAddress)) {
+      ctx.addIssue({
+        path: ["destinationAddress"],
+        message: "Invalid destination address format",
+        code: z.ZodIssueCode.custom,
+      });
+      issues.push("destinationAddress");
+    }
+  }
+
+  return issues.length === 0;
 });
 
 export type AddDomainValues = z.infer<typeof addDomainSchema>

src/app/api/domain/domain-types.ts

@@ -8,5 +8,6 @@ export type DomainWithCheckResults = {
 	createdAt: Date;
 	isLocked: boolean;
 	enableHttps: boolean;
+	redirectUrl?: string;
 	checkResults: DomainCheckResults;
 };

src/app/api/domain/registered/route.ts

@@ -39,6 +39,7 @@ export async function GET(request: NextRequest) {
       const domainCheckResults = await checkDomain(domain.incomingAddress);
       domainsWithCheckResults.push({
         ...domain,
+        redirectUrl: domain?.redirectUrl || undefined,
         checkResults: domainCheckResults,
       });
     }