refactor(networks): streamline network management and enhance validation

- Simplified the network form schema by removing unnecessary fields and enforcing validation rules for IP settings.
- Updated the HandleNetwork component to eliminate the edit functionality, focusing on network creation only.
- Improved the ShowNetworks component by adding a delete action for network management, enhancing user experience.
- Introduced a new SQL migration for the network schema, establishing necessary constraints and types.
- Cleaned up the API by removing the update network functionality, reflecting the immutable nature of Docker networks.

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

@@ -6,15 +6,14 @@ import { z } from "zod";
 import { organization } from "./account";
 import { server } from "./server";
 
-/** Docker network driver types */
-export const networkDriver = pgEnum("networkDriver", [
-	"bridge",
-	"host",
-	"overlay",
-	"macvlan",
-	"none",
-	"ipvlan",
-]);
+/**
+ * Docker network driver types. Only bridge and overlay are supported:
+ * "host"/"none" are Docker singletons that cannot be created, and
+ * macvlan/ipvlan require driver options (parent interface) we don't expose.
+ * Scope is derived from the driver (bridge = local, overlay = swarm), and
+ * ingress/config-only networks are not manageable from Dokploy.
+ */
+export const networkDriver = pgEnum("networkDriver", ["bridge", "overlay"]);
 
 export const network = pgTable("network", {
 	networkId: text("networkId")
@@ -23,11 +22,8 @@ export const network = pgTable("network", {
 		.$defaultFn(() => nanoid()),
 	name: text("name").notNull(),
 	driver: networkDriver("driver").notNull().default("bridge"),
-	scope: text("scope"), // e.g. "local", "swarm"
 	internal: boolean("internal").notNull().default(false),
 	attachable: boolean("attachable").notNull().default(false),
-	ingress: boolean("ingress").notNull().default(false),
-	configOnly: boolean("configOnly").notNull().default(false),
 	enableIPv4: boolean("enableIPv4").notNull().default(true),
 	enableIPv6: boolean("enableIPv6").notNull().default(false),
 	ipam: jsonb("ipam")
@@ -61,14 +57,9 @@ export const networkRelations = relations(network, ({ one }) => ({
 const createSchema = createInsertSchema(network, {
 	networkId: z.string().min(1),
 	name: z.string().min(1),
-	driver: z
-		.enum(["bridge", "host", "overlay", "macvlan", "none", "ipvlan"])
-		.optional(),
-	scope: z.string().optional(),
+	driver: z.enum(["bridge", "overlay"]).optional(),
 	internal: z.boolean().optional(),
 	attachable: z.boolean().optional(),
-	ingress: z.boolean().optional(),
-	configOnly: z.boolean().optional(),
 	enableIPv4: z.boolean().optional(),
 	enableIPv6: z.boolean().optional(),
 	ipam: z
@@ -89,22 +80,48 @@ const createSchema = createInsertSchema(network, {
 	serverId: z.string().optional().nullable(),
 });
 
+const validateNetworkInput = (
+	input: {
+		enableIPv4?: boolean;
+		enableIPv6?: boolean;
+		ipam?: {
+			config?: Array<{ subnet?: string; gateway?: string; ipRange?: string }>;
+		} | null;
+	},
+	ctx: z.RefinementCtx,
+) => {
+	if (input.enableIPv4 === false && input.enableIPv6 !== true) {
+		ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			path: ["enableIPv4"],
+			message: "IPv4 or IPv6 must be enabled",
+		});
+	}
+	for (const [index, entry] of (input.ipam?.config ?? []).entries()) {
+		if (!entry.subnet && (entry.gateway || entry.ipRange)) {
+			ctx.addIssue({
+				code: z.ZodIssueCode.custom,
+				path: ["ipam", "config", index, "subnet"],
+				message: "Gateway and IP range require a subnet",
+			});
+		}
+	}
+};
+
 export const apiCreateNetwork = createSchema
 	.pick({
 		name: true,
 		driver: true,
-		scope: true,
 		internal: true,
 		attachable: true,
-		ingress: true,
-		configOnly: true,
 		enableIPv4: true,
 		enableIPv6: true,
 		ipam: true,
 		serverId: true,
 	})
 	.partial()
-	.required({ name: true });
+	.required({ name: true })
+	.superRefine(validateNetworkInput);
 
 export const apiFindOneNetwork = createSchema
 	.pick({
@@ -117,21 +134,3 @@ export const apiRemoveNetwork = createSchema
 		networkId: true,
 	})
 	.required();
-
-export const apiUpdateNetwork = createSchema
-	.pick({
-		networkId: true,
-		name: true,
-		driver: true,
-		scope: true,
-		internal: true,
-		attachable: true,
-		ingress: true,
-		configOnly: true,
-		enableIPv4: true,
-		enableIPv6: true,
-		ipam: true,
-		serverId: true,
-	})
-	.partial()
-	.required({ networkId: true });

packages/server/src/services/network.ts

@@ -1,9 +1,5 @@
 import { db } from "@dokploy/server/db";
-import {
-	type apiCreateNetwork,
-	type apiUpdateNetwork,
-	network,
-} from "@dokploy/server/db/schema";
+import { type apiCreateNetwork, network } from "@dokploy/server/db/schema";
 import { TRPCError } from "@trpc/server";
 import { eq } from "drizzle-orm";
 import type { z } from "zod";
@@ -68,18 +64,32 @@ export const createNetwork = async (
 			.filter((e) => Object.keys(e).length > 0);
 
 		const docker = await getRemoteDocker(input.serverId ?? null);
-		await docker.createNetwork({
-			Name: row.name,
-			Driver: row.driver,
-			Internal: row.internal,
-			Attachable: row.attachable,
-			Ingress: row.ingress,
-			EnableIPv6: row.enableIPv6,
-			IPAM: {
-				Driver: ipam.driver ?? "default",
-				Config: ipamConfig.length > 0 ? ipamConfig : undefined,
-			},
-		});
+		try {
+			await docker.createNetwork({
+				Name: row.name,
+				Driver: row.driver,
+				CheckDuplicate: true,
+				Internal: row.internal,
+				Attachable: row.attachable,
+				// EnableIPv4 is missing from dockerode's types but supported by
+				// the daemon (API >= 1.47); the body is sent as-is
+				EnableIPv4: row.enableIPv4,
+				EnableIPv6: row.enableIPv6,
+				IPAM: {
+					Driver: ipam.driver || "default",
+					Config: ipamConfig.length > 0 ? ipamConfig : undefined,
+				},
+			} as Parameters<typeof docker.createNetwork>[0]);
+		} catch (error) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message:
+					error instanceof Error
+						? error.message
+						: "Failed to create Docker network",
+				cause: error,
+			});
+		}
 
 		return row;
 	});
@@ -87,27 +97,28 @@ export const createNetwork = async (
 	return created;
 };
 
-export const updateNetwork = async (
-	input: z.infer<typeof apiUpdateNetwork>,
-) => {
-	const { networkId, ...rest } = input;
-	const [updated] = await db
-		.update(network)
-		.set(rest)
-		.where(eq(network.networkId, networkId))
-		.returning();
+// Docker networks are immutable: there is no update, only create and remove.
+export const removeNetwork = async (networkId: string) => {
+	const row = await findNetworkById(networkId);
 
-	if (!updated) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Network not found",
-		});
+	const docker = await getRemoteDocker(row.serverId ?? null);
+	try {
+		await docker.getNetwork(row.name).remove();
+	} catch (error) {
+		// If the network is already gone from Docker, still clean up the DB row
+		const statusCode = (error as { statusCode?: number })?.statusCode;
+		if (statusCode !== 404) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message:
+					error instanceof Error
+						? error.message
+						: "Failed to remove Docker network",
+				cause: error,
+			});
+		}
 	}
 
-	return updated;
-};
-
-export const removeNetwork = async (networkId: string) => {
 	const [deleted] = await db
 		.delete(network)
 		.where(eq(network.networkId, networkId))