chore: format whole repository with new configs

server/api/root.ts

@@ -1,28 +1,28 @@
-import { createTRPCRouter } from "../api/trpc";
 import { authRouter } from "@/server/api/routers/auth";
-import { projectRouter } from "./routers/project";
-import { applicationRouter } from "./routers/application";
-import { mysqlRouter } from "./routers/mysql";
-import { postgresRouter } from "./routers/postgres";
-import { redisRouter } from "./routers/redis";
-import { mongoRouter } from "./routers/mongo";
-import { mariadbRouter } from "./routers/mariadb";
-import { userRouter } from "./routers/user";
-import { domainRouter } from "./routers/domain";
-import { destinationRouter } from "./routers/destination";
-import { backupRouter } from "./routers/backup";
-import { deploymentRouter } from "./routers/deployment";
-import { mountRouter } from "./routers/mount";
-import { certificateRouter } from "./routers/certificate";
-import { settingsRouter } from "./routers/settings";
-import { redirectsRouter } from "./routers/redirects";
-import { securityRouter } from "./routers/security";
-import { portRouter } from "./routers/port";
+import { createTRPCRouter } from "../api/trpc";
 import { adminRouter } from "./routers/admin";
-import { dockerRouter } from "./routers/docker";
-import { composeRouter } from "./routers/compose";
-import { registryRouter } from "./routers/registry";
+import { applicationRouter } from "./routers/application";
+import { backupRouter } from "./routers/backup";
+import { certificateRouter } from "./routers/certificate";
 import { clusterRouter } from "./routers/cluster";
+import { composeRouter } from "./routers/compose";
+import { deploymentRouter } from "./routers/deployment";
+import { destinationRouter } from "./routers/destination";
+import { dockerRouter } from "./routers/docker";
+import { domainRouter } from "./routers/domain";
+import { mariadbRouter } from "./routers/mariadb";
+import { mongoRouter } from "./routers/mongo";
+import { mountRouter } from "./routers/mount";
+import { mysqlRouter } from "./routers/mysql";
+import { portRouter } from "./routers/port";
+import { postgresRouter } from "./routers/postgres";
+import { projectRouter } from "./routers/project";
+import { redirectsRouter } from "./routers/redirects";
+import { redisRouter } from "./routers/redis";
+import { registryRouter } from "./routers/registry";
+import { securityRouter } from "./routers/security";
+import { settingsRouter } from "./routers/settings";
+import { userRouter } from "./routers/user";
 
 /**
  * This is the primary router for your server.

server/api/routers/admin.ts

@@ -1,3 +1,4 @@
+import { db } from "@/server/db";
 import {
 	apiAssignPermissions,
 	apiCreateUserInvitation,
@@ -6,6 +7,11 @@ import {
 	apiRemoveUser,
 	users,
 } from "@/server/db/schema";
+import { haveGithubRequirements } from "@/server/utils/providers/github";
+import { createAppAuth } from "@octokit/auth-app";
+import { TRPCError } from "@trpc/server";
+import { eq } from "drizzle-orm";
+import { Octokit } from "octokit";
 import {
 	createInvitation,
 	findAdmin,
@@ -19,12 +25,6 @@ import {
 	protectedProcedure,
 	publicProcedure,
 } from "../trpc";
-import { db } from "@/server/db";
-import { TRPCError } from "@trpc/server";
-import { eq } from "drizzle-orm";
-import { Octokit } from "octokit";
-import { createAppAuth } from "@octokit/auth-app";
-import { haveGithubRequirements } from "@/server/utils/providers/github";
 
 export const adminRouter = createTRPCRouter({
 	one: adminProcedure.query(async () => {

server/api/routers/application.ts

@@ -14,8 +14,8 @@ import {
 	applications,
 } from "@/server/db/schema/application";
 import {
-	cleanQueuesByApplication,
 	type DeploymentJob,
+	cleanQueuesByApplication,
 } from "@/server/queues/deployments-queue";
 import { myQueue } from "@/server/queues/queueSetup";
 import {
@@ -37,8 +37,11 @@ import {
 	removeTraefikConfig,
 	writeConfig,
 } from "@/server/utils/traefik/application";
+import { deleteAllMiddlewares } from "@/server/utils/traefik/middleware";
 import { TRPCError } from "@trpc/server";
 import { eq } from "drizzle-orm";
+import { nanoid } from "nanoid";
+import { z } from "zod";
 import {
 	createApplication,
 	findApplicationById,
@@ -47,9 +50,6 @@ import {
 	updateApplicationStatus,
 } from "../services/application";
 import { removeDeployments } from "../services/deployment";
-import { deleteAllMiddlewares } from "@/server/utils/traefik/middleware";
-import { z } from "zod";
-import { nanoid } from "nanoid";
 import { addNewService, checkServiceAccess } from "../services/user";
 
 export const applicationRouter = createTRPCRouter({

server/api/routers/auth.ts

@@ -1,22 +1,17 @@
-import { TRPCError } from "@trpc/server";
-import * as bcrypt from "bcrypt";
-import {
-	adminProcedure,
-	createTRPCRouter,
-	protectedProcedure,
-	publicProcedure,
-} from "../trpc";
 import { lucia, validateRequest } from "@/server/auth/auth";
+import { luciaToken } from "@/server/auth/token";
 import {
 	apiCreateAdmin,
 	apiCreateUser,
 	apiFindOneAuth,
-	apiUpdateAuthByAdmin,
 	apiLogin,
 	apiUpdateAuth,
+	apiUpdateAuthByAdmin,
 	apiVerify2FA,
 	apiVerifyLogin2FA,
 } from "@/server/db/schema";
+import { TRPCError } from "@trpc/server";
+import * as bcrypt from "bcrypt";
 import {
 	createAdmin,
 	createUser,
@@ -26,7 +21,12 @@ import {
 	updateAuthById,
 	verify2FA,
 } from "../services/auth";
-import { luciaToken } from "@/server/auth/token";
+import {
+	adminProcedure,
+	createTRPCRouter,
+	protectedProcedure,
+	publicProcedure,
+} from "../trpc";
 
 export const authRouter = createTRPCRouter({
 	createAdmin: publicProcedure

server/api/routers/backup.ts

@@ -9,6 +9,10 @@ import { runMariadbBackup } from "@/server/utils/backups/mariadb";
 import { runMongoBackup } from "@/server/utils/backups/mongo";
 import { runMySqlBackup } from "@/server/utils/backups/mysql";
 import { runPostgresBackup } from "@/server/utils/backups/postgres";
+import {
+	removeScheduleBackup,
+	scheduleBackup,
+} from "@/server/utils/backups/utils";
 import { TRPCError } from "@trpc/server";
 import {
 	createBackup,
@@ -20,10 +24,6 @@ import { findMariadbByBackupId } from "../services/mariadb";
 import { findMongoByBackupId } from "../services/mongo";
 import { findMySqlByBackupId } from "../services/mysql";
 import { findPostgresByBackupId } from "../services/postgres";
-import {
-	removeScheduleBackup,
-	scheduleBackup,
-} from "@/server/utils/backups/utils";
 
 export const backupRouter = createTRPCRouter({
 	create: protectedProcedure

server/api/routers/certificate.ts

@@ -2,8 +2,8 @@ import { adminProcedure, createTRPCRouter } from "@/server/api/trpc";
 import { apiCreateCertificate, apiFindCertificate } from "@/server/db/schema";
 import {
 	createCertificate,
-	findCertificates,
 	findCertificateById,
+	findCertificates,
 	removeCertificateById,
 } from "../services/certificate";
 

server/api/routers/cluster.ts

@@ -1,10 +1,10 @@
 import { docker } from "@/server/constants";
-import { createTRPCRouter, protectedProcedure } from "../trpc";
-import { getPublicIpWithFallback } from "@/server/wss/terminal";
-import type { DockerNode } from "../services/cluster";
-import { z } from "zod";
-import { TRPCError } from "@trpc/server";
 import { execAsync } from "@/server/utils/process/execAsync";
+import { getPublicIpWithFallback } from "@/server/wss/terminal";
+import { TRPCError } from "@trpc/server";
+import { z } from "zod";
+import type { DockerNode } from "../services/cluster";
+import { createTRPCRouter, protectedProcedure } from "../trpc";
 
 export const clusterRouter = createTRPCRouter({
 	getNodes: protectedProcedure.query(async () => {

server/api/routers/compose.ts

@@ -1,3 +1,5 @@
+import { slugify } from "@/lib/slug";
+import { db } from "@/server/db";
 import {
 	apiCreateCompose,
 	apiCreateComposeByTemplate,
@@ -6,6 +8,30 @@ import {
 	apiUpdateCompose,
 	compose,
 } from "@/server/db/schema";
+import {
+	type DeploymentJob,
+	cleanQueuesByCompose,
+} from "@/server/queues/deployments-queue";
+import { myQueue } from "@/server/queues/queueSetup";
+import { createCommand } from "@/server/utils/builders/compose";
+import { randomizeComposeFile } from "@/server/utils/docker/compose";
+import { removeComposeDirectory } from "@/server/utils/filesystem/directory";
+import {
+	generateSSHKey,
+	readRSAFile,
+	removeRSAFiles,
+} from "@/server/utils/filesystem/ssh";
+import { templates } from "@/templates/templates";
+import type { TemplatesKeys } from "@/templates/types/templates-data.type";
+import {
+	generatePassword,
+	loadTemplateModule,
+	readComposeFile,
+} from "@/templates/utils";
+import { TRPCError } from "@trpc/server";
+import { eq } from "drizzle-orm";
+import { nanoid } from "nanoid";
+import { findAdmin } from "../services/admin";
 import {
 	createCompose,
 	createComposeByTemplate,
@@ -15,37 +41,11 @@ import {
 	stopCompose,
 	updateCompose,
 } from "../services/compose";
-import { createTRPCRouter, protectedProcedure } from "../trpc";
-import { addNewService, checkServiceAccess } from "../services/user";
-import {
-	cleanQueuesByCompose,
-	type DeploymentJob,
-} from "@/server/queues/deployments-queue";
-import { myQueue } from "@/server/queues/queueSetup";
-import {
-	generateSSHKey,
-	readRSAFile,
-	removeRSAFiles,
-} from "@/server/utils/filesystem/ssh";
-import { eq } from "drizzle-orm";
-import { db } from "@/server/db";
-import { randomizeComposeFile } from "@/server/utils/docker/compose";
-import { nanoid } from "nanoid";
 import { removeDeploymentsByComposeId } from "../services/deployment";
-import { removeComposeDirectory } from "@/server/utils/filesystem/directory";
-import { createCommand } from "@/server/utils/builders/compose";
-import {
-	generatePassword,
-	loadTemplateModule,
-	readComposeFile,
-} from "@/templates/utils";
-import { findAdmin } from "../services/admin";
-import { TRPCError } from "@trpc/server";
-import { findProjectById } from "../services/project";
 import { createMount } from "../services/mount";
-import type { TemplatesKeys } from "@/templates/types/templates-data.type";
-import { templates } from "@/templates/templates";
-import { slugify } from "@/lib/slug";
+import { findProjectById } from "../services/project";
+import { addNewService, checkServiceAccess } from "../services/user";
+import { createTRPCRouter, protectedProcedure } from "../trpc";
 
 export const composeRouter = createTRPCRouter({
 	create: protectedProcedure

server/api/routers/destination.ts

@@ -12,13 +12,13 @@ import {
 } from "@/server/db/schema";
 import { HeadBucketCommand, S3Client } from "@aws-sdk/client-s3";
 import { TRPCError } from "@trpc/server";
+import { findAdmin } from "../services/admin";
 import {
 	createDestintation,
 	findDestinationById,
 	removeDestinationById,
 	updateDestinationById,
 } from "../services/destination";
-import { findAdmin } from "../services/admin";
 
 export const destinationRouter = createTRPCRouter({
 	create: adminProcedure

server/api/routers/docker.ts

@@ -1,11 +1,11 @@
 import { z } from "zod";
-import { createTRPCRouter, protectedProcedure } from "../trpc";
 import {
 	getConfig,
-	getContainersByAppLabel,
 	getContainers,
+	getContainersByAppLabel,
 	getContainersByAppNameMatch,
 } from "../services/docker";
+import { createTRPCRouter, protectedProcedure } from "../trpc";
 
 export const dockerRouter = createTRPCRouter({
 	getContainers: protectedProcedure.query(async () => {

server/api/routers/mariadb.ts

@@ -22,8 +22,8 @@ import {
 	removeMariadbById,
 	updateMariadbById,
 } from "../services/mariadb";
-import { addNewService, checkServiceAccess } from "../services/user";
 import { createMount } from "../services/mount";
+import { addNewService, checkServiceAccess } from "../services/user";
 
 export const mariadbRouter = createTRPCRouter({
 	create: protectedProcedure

server/api/routers/mongo.ts

@@ -22,8 +22,8 @@ import {
 	removeMongoById,
 	updateMongoById,
 } from "../services/mongo";
-import { addNewService, checkServiceAccess } from "../services/user";
 import { createMount } from "../services/mount";
+import { addNewService, checkServiceAccess } from "../services/user";
 
 export const mongoRouter = createTRPCRouter({
 	create: protectedProcedure

server/api/routers/mysql.ts

@@ -15,6 +15,8 @@ import {
 	stopService,
 } from "@/server/utils/docker/utils";
 import { TRPCError } from "@trpc/server";
+import { z } from "zod";
+import { createMount } from "../services/mount";
 import {
 	createMysql,
 	deployMySql,
@@ -23,8 +25,6 @@ import {
 	updateMySqlById,
 } from "../services/mysql";
 import { addNewService, checkServiceAccess } from "../services/user";
-import { createMount } from "../services/mount";
-import { z } from "zod";
 
 export const mysqlRouter = createTRPCRouter({
 	create: protectedProcedure

server/api/routers/port.ts

@@ -1,10 +1,10 @@
-import { TRPCError } from "@trpc/server";
 import { createTRPCRouter, protectedProcedure } from "@/server/api/trpc";
 import {
 	apiCreatePort,
 	apiFindOnePort,
 	apiUpdatePort,
 } from "@/server/db/schema/port";
+import { TRPCError } from "@trpc/server";
 import {
 	createPort,
 	finPortById,

server/api/routers/postgres.ts

@@ -15,6 +15,7 @@ import {
 	stopService,
 } from "@/server/utils/docker/utils";
 import { TRPCError } from "@trpc/server";
+import { createMount } from "../services/mount";
 import {
 	createPostgres,
 	deployPostgres,
@@ -23,7 +24,6 @@ import {
 	updatePostgresById,
 } from "../services/postgres";
 import { addNewService, checkServiceAccess } from "../services/user";
-import { createMount } from "../services/mount";
 
 export const postgresRouter = createTRPCRouter({
 	create: protectedProcedure

server/api/routers/project.ts

@@ -4,6 +4,15 @@ import {
 	protectedProcedure,
 } from "@/server/api/trpc";
 import { db } from "@/server/db";
+import {
+	applications,
+	compose,
+	mariadb,
+	mongo,
+	mysql,
+	postgres,
+	redis,
+} from "@/server/db/schema";
 import {
 	apiCreateProject,
 	apiFindOneProject,
@@ -13,6 +22,7 @@ import {
 } from "@/server/db/schema/project";
 import { TRPCError } from "@trpc/server";
 import { desc, eq, sql } from "drizzle-orm";
+import type { AnyPgColumn } from "drizzle-orm/pg-core";
 import {
 	createProject,
 	deleteProject,
@@ -24,16 +34,6 @@ import {
 	checkProjectAccess,
 	findUserByAuthId,
 } from "../services/user";
-import {
-	applications,
-	compose,
-	mariadb,
-	mongo,
-	mysql,
-	postgres,
-	redis,
-} from "@/server/db/schema";
-import type { AnyPgColumn } from "drizzle-orm/pg-core";
 
 export const projectRouter = createTRPCRouter({
 	create: protectedProcedure

server/api/routers/redirects.ts

@@ -1,4 +1,3 @@
-import { createTRPCRouter, protectedProcedure } from "../trpc";
 import {
 	apiCreateRedirect,
 	apiFindOneRedirect,
@@ -10,6 +9,7 @@ import {
 	removeRedirectById,
 	updateRedirectById,
 } from "../services/redirect";
+import { createTRPCRouter, protectedProcedure } from "../trpc";
 
 export const redirectsRouter = createTRPCRouter({
 	create: protectedProcedure

server/api/routers/redis.ts

@@ -15,6 +15,7 @@ import {
 	stopService,
 } from "@/server/utils/docker/utils";
 import { TRPCError } from "@trpc/server";
+import { createMount } from "../services/mount";
 import {
 	createRedis,
 	deployRedis,
@@ -23,7 +24,6 @@ import {
 	updateRedisById,
 } from "../services/redis";
 import { addNewService, checkServiceAccess } from "../services/user";
-import { createMount } from "../services/mount";
 
 export const redisRouter = createTRPCRouter({
 	create: protectedProcedure

server/api/routers/registry.ts

@@ -6,6 +6,10 @@ import {
 	apiTestRegistry,
 	apiUpdateRegistry,
 } from "@/server/db/schema";
+import { initializeRegistry } from "@/server/setup/registry-setup";
+import { execAsync } from "@/server/utils/process/execAsync";
+import { manageRegistry } from "@/server/utils/traefik/registry";
+import { TRPCError } from "@trpc/server";
 import {
 	createRegistry,
 	findAllRegistry,
@@ -14,10 +18,6 @@ import {
 	updateRegistry,
 } from "../services/registry";
 import { adminProcedure, createTRPCRouter, protectedProcedure } from "../trpc";
-import { TRPCError } from "@trpc/server";
-import { manageRegistry } from "@/server/utils/traefik/registry";
-import { initializeRegistry } from "@/server/setup/registry-setup";
-import { execAsync } from "@/server/utils/process/execAsync";
 
 export const registryRouter = createTRPCRouter({
 	create: adminProcedure

server/api/routers/security.ts

@@ -1,4 +1,3 @@
-import { createTRPCRouter, protectedProcedure } from "../trpc";
 import {
 	apiCreateSecurity,
 	apiFindOneSecurity,
@@ -10,6 +9,7 @@ import {
 	findSecurityById,
 	updateSecurityById,
 } from "../services/security";
+import { createTRPCRouter, protectedProcedure } from "../trpc";
 
 export const securityRouter = createTRPCRouter({
 	create: protectedProcedure

server/api/routers/settings.ts

@@ -1,5 +1,12 @@
-import { docker, MAIN_TRAEFIK_PATH, MONITORING_PATH } from "@/server/constants";
-import { adminProcedure, createTRPCRouter, protectedProcedure } from "../trpc";
+import { MAIN_TRAEFIK_PATH, MONITORING_PATH, docker } from "@/server/constants";
+import {
+	apiAssignDomain,
+	apiModifyTraefikConfig,
+	apiReadTraefikConfig,
+	apiSaveSSHKey,
+	apiTraefikConfig,
+	apiUpdateDockerCleanup,
+} from "@/server/db/schema";
 import {
 	cleanStoppedContainers,
 	cleanUpDockerBuilder,
@@ -9,40 +16,33 @@ import {
 	startService,
 	stopService,
 } from "@/server/utils/docker/utils";
-import {
-	apiAssignDomain,
-	apiModifyTraefikConfig,
-	apiReadTraefikConfig,
-	apiSaveSSHKey,
-	apiTraefikConfig,
-	apiUpdateDockerCleanup,
-} from "@/server/db/schema";
-import { scheduledJobs, scheduleJob } from "node-schedule";
-import {
-	readMainConfig,
-	updateLetsEncryptEmail,
-	updateServerTraefik,
-	writeMainConfig,
-} from "@/server/utils/traefik/web-server";
+import { recreateDirectory } from "@/server/utils/filesystem/directory";
+import { spawnAsync } from "@/server/utils/process/spawnAsync";
 import {
 	readConfig,
 	readConfigInPath,
 	writeConfig,
 	writeTraefikConfigInPath,
 } from "@/server/utils/traefik/application";
-import { spawnAsync } from "@/server/utils/process/spawnAsync";
-import { findAdmin, updateAdmin } from "../services/admin";
-import { TRPCError } from "@trpc/server";
 import {
-	getDokployVersion,
+	readMainConfig,
+	updateLetsEncryptEmail,
+	updateServerTraefik,
+	writeMainConfig,
+} from "@/server/utils/traefik/web-server";
+import { generateOpenApiDocument } from "@dokploy/trpc-openapi";
+import { TRPCError } from "@trpc/server";
+import { scheduleJob, scheduledJobs } from "node-schedule";
+import { appRouter } from "../root";
+import { findAdmin, updateAdmin } from "../services/admin";
+import {
 	getDokployImage,
+	getDokployVersion,
 	pullLatestRelease,
 	readDirectory,
 } from "../services/settings";
 import { canAccessToTraefikFiles } from "../services/user";
-import { recreateDirectory } from "@/server/utils/filesystem/directory";
-import { generateOpenApiDocument } from "@dokploy/trpc-openapi";
-import { appRouter } from "../root";
+import { adminProcedure, createTRPCRouter, protectedProcedure } from "../trpc";
 
 export const settingsRouter = createTRPCRouter({
 	reloadServer: adminProcedure.mutation(async () => {

server/api/services/admin.ts

@@ -1,3 +1,4 @@
+import { randomBytes } from "node:crypto";
 import { db } from "@/server/db";
 import {
 	admins,
@@ -6,10 +7,9 @@ import {
 	users,
 } from "@/server/db/schema";
 import { TRPCError } from "@trpc/server";
+import * as bcrypt from "bcrypt";
 import { isAfter } from "date-fns";
 import { eq } from "drizzle-orm";
-import * as bcrypt from "bcrypt";
-import { randomBytes } from "node:crypto";
 
 export type Admin = typeof admins.$inferSelect;
 

server/api/services/application.ts

@@ -1,23 +1,23 @@
+import { docker } from "@/server/constants";
 import { db } from "@/server/db";
 import {
 	type apiCreateApplication,
 	applications,
 	domains,
 } from "@/server/db/schema";
+import { generateAppName } from "@/server/db/schema/utils";
+import { getAdvancedStats } from "@/server/monitoring/utilts";
 import { buildApplication } from "@/server/utils/builders";
 import { buildDocker } from "@/server/utils/providers/docker";
 import { cloneGitRepository } from "@/server/utils/providers/git";
 import { cloneGithubRepository } from "@/server/utils/providers/github";
+import { createTraefikConfig } from "@/server/utils/traefik/application";
+import { generatePassword } from "@/templates/utils";
 import { TRPCError } from "@trpc/server";
 import { eq } from "drizzle-orm";
-import { createDeployment, updateDeploymentStatus } from "./deployment";
 import { findAdmin } from "./admin";
-import { createTraefikConfig } from "@/server/utils/traefik/application";
-import { docker } from "@/server/constants";
-import { getAdvancedStats } from "@/server/monitoring/utilts";
+import { createDeployment, updateDeploymentStatus } from "./deployment";
 import { validUniqueServerAppName } from "./project";
-import { generatePassword } from "@/templates/utils";
-import { generateAppName } from "@/server/db/schema/utils";
 export type Application = typeof applications.$inferSelect;
 
 export const createApplication = async (

server/api/services/auth.ts

@@ -1,3 +1,4 @@
+import { randomBytes } from "node:crypto";
 import { db } from "@/server/db";
 import {
 	admins,
@@ -6,11 +7,10 @@ import {
 	auth,
 	users,
 } from "@/server/db/schema";
+import { getPublicIpWithFallback } from "@/server/wss/terminal";
 import { TRPCError } from "@trpc/server";
 import * as bcrypt from "bcrypt";
-import { getPublicIpWithFallback } from "@/server/wss/terminal";
 import { eq } from "drizzle-orm";
-import { randomBytes } from "node:crypto";
 import encode from "hi-base32";
 import { TOTP } from "otpauth";
 import QRCode from "qrcode";

server/api/services/certificate.ts

@@ -3,11 +3,11 @@ import path from "node:path";
 import { CERTIFICATES_PATH } 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 type { z } from "zod";
 import { dump } from "js-yaml";
-import { removeDirectoryIfExistsContent } from "@/server/utils/filesystem/directory";
+import type { z } from "zod";
 
 export type Certificate = typeof certificates.$inferSelect;
 

server/api/services/compose.ts

@@ -1,21 +1,21 @@
+import { join } from "node:path";
+import { COMPOSE_PATH } from "@/server/constants";
 import { db } from "@/server/db";
 import { type apiCreateCompose, compose } from "@/server/db/schema";
+import { generateAppName } from "@/server/db/schema/utils";
+import { buildCompose } from "@/server/utils/builders/compose";
 import type { ComposeSpecification } from "@/server/utils/docker/types";
+import { execAsync } from "@/server/utils/process/execAsync";
+import { cloneGitRepository } from "@/server/utils/providers/git";
+import { cloneGithubRepository } from "@/server/utils/providers/github";
+import { createComposeFile } from "@/server/utils/providers/raw";
+import { generatePassword } from "@/templates/utils";
 import { TRPCError } from "@trpc/server";
 import { eq } from "drizzle-orm";
 import { load } from "js-yaml";
 import { findAdmin } from "./admin";
 import { createDeploymentCompose, updateDeploymentStatus } from "./deployment";
-import { buildCompose } from "@/server/utils/builders/compose";
-import { createComposeFile } from "@/server/utils/providers/raw";
-import { execAsync } from "@/server/utils/process/execAsync";
-import { join } from "node:path";
-import { COMPOSE_PATH } from "@/server/constants";
-import { cloneGithubRepository } from "@/server/utils/providers/github";
-import { cloneGitRepository } from "@/server/utils/providers/git";
 import { validUniqueServerAppName } from "./project";
-import { generateAppName } from "@/server/db/schema/utils";
-import { generatePassword } from "@/templates/utils";
 
 export type Compose = typeof compose.$inferSelect;
 

server/api/services/domain.ts

@@ -4,12 +4,12 @@ import {
 	type apiFindDomainByApplication,
 	domains,
 } from "@/server/db/schema";
+import { manageDomain } from "@/server/utils/traefik/domain";
+import { generateRandomDomain } from "@/templates/utils";
 import { TRPCError } from "@trpc/server";
 import { eq } from "drizzle-orm";
-import { findApplicationById } from "./application";
-import { manageDomain } from "@/server/utils/traefik/domain";
 import { findAdmin } from "./admin";
-import { generateRandomDomain } from "@/templates/utils";
+import { findApplicationById } from "./application";
 
 export type Domain = typeof domains.$inferSelect;
 

server/api/services/mariadb.ts

@@ -1,13 +1,13 @@
 import { generateRandomPassword } from "@/server/auth/random-password";
 import { db } from "@/server/db";
 import { type apiCreateMariaDB, backups, mariadb } from "@/server/db/schema";
+import { generateAppName } from "@/server/db/schema/utils";
 import { buildMariadb } from "@/server/utils/databases/mariadb";
 import { pullImage } from "@/server/utils/docker/utils";
+import { generatePassword } from "@/templates/utils";
 import { TRPCError } from "@trpc/server";
 import { eq, getTableColumns } from "drizzle-orm";
 import { validUniqueServerAppName } from "./project";
-import { generateAppName } from "@/server/db/schema/utils";
-import { generatePassword } from "@/templates/utils";
 
 export type Mariadb = typeof mariadb.$inferSelect;
 

server/api/services/mongo.ts

@@ -1,13 +1,13 @@
 import { generateRandomPassword } from "@/server/auth/random-password";
 import { db } from "@/server/db";
 import { type apiCreateMongo, backups, mongo } from "@/server/db/schema";
+import { generateAppName } from "@/server/db/schema/utils";
 import { buildMongo } from "@/server/utils/databases/mongo";
 import { pullImage } from "@/server/utils/docker/utils";
+import { generatePassword } from "@/templates/utils";
 import { TRPCError } from "@trpc/server";
 import { eq, getTableColumns } from "drizzle-orm";
 import { validUniqueServerAppName } from "./project";
-import { generateAppName } from "@/server/db/schema/utils";
-import { generatePassword } from "@/templates/utils";
 
 export type Mongo = typeof mongo.$inferSelect;
 

server/api/services/mount.ts

@@ -3,12 +3,12 @@ import path from "node:path";
 import { APPLICATIONS_PATH } from "@/server/constants";
 import { db } from "@/server/db";
 import {
+	type ServiceType,
 	type apiCreateMount,
 	mounts,
-	type ServiceType,
 } from "@/server/db/schema";
 import { TRPCError } from "@trpc/server";
-import { eq, sql, type SQL } from "drizzle-orm";
+import { type SQL, eq, sql } from "drizzle-orm";
 
 export type Mount = typeof mounts.$inferSelect;
 

server/api/services/mysql.ts

@@ -1,13 +1,13 @@
 import { generateRandomPassword } from "@/server/auth/random-password";
 import { db } from "@/server/db";
 import { type apiCreateMySql, backups, mysql } from "@/server/db/schema";
+import { generateAppName } from "@/server/db/schema/utils";
 import { buildMysql } from "@/server/utils/databases/mysql";
 import { pullImage } from "@/server/utils/docker/utils";
+import { generatePassword } from "@/templates/utils";
 import { TRPCError } from "@trpc/server";
 import { eq, getTableColumns } from "drizzle-orm";
 import { validUniqueServerAppName } from "./project";
-import { generatePassword } from "@/templates/utils";
-import { generateAppName } from "@/server/db/schema/utils";
 
 export type MySql = typeof mysql.$inferSelect;
 

server/api/services/postgres.ts

@@ -1,13 +1,13 @@
 import { generateRandomPassword } from "@/server/auth/random-password";
 import { db } from "@/server/db";
 import { type apiCreatePostgres, backups, postgres } from "@/server/db/schema";
+import { generateAppName } from "@/server/db/schema/utils";
 import { buildPostgres } from "@/server/utils/databases/postgres";
 import { pullImage } from "@/server/utils/docker/utils";
+import { generatePassword } from "@/templates/utils";
 import { TRPCError } from "@trpc/server";
 import { eq, getTableColumns } from "drizzle-orm";
 import { validUniqueServerAppName } from "./project";
-import { generatePassword } from "@/templates/utils";
-import { generateAppName } from "@/server/db/schema/utils";
 
 export type Postgres = typeof postgres.$inferSelect;
 

server/api/services/redis.ts

@@ -1,13 +1,13 @@
 import { generateRandomPassword } from "@/server/auth/random-password";
 import { db } from "@/server/db";
 import { type apiCreateRedis, redis } from "@/server/db/schema";
+import { generateAppName } from "@/server/db/schema/utils";
 import { buildRedis } from "@/server/utils/databases/redis";
 import { pullImage } from "@/server/utils/docker/utils";
+import { generatePassword } from "@/templates/utils";
 import { TRPCError } from "@trpc/server";
 import { eq } from "drizzle-orm";
 import { validUniqueServerAppName } from "./project";
-import { generateAppName } from "@/server/db/schema/utils";
-import { generatePassword } from "@/templates/utils";
 
 export type Redis = typeof redis.$inferSelect;
 

server/api/services/registry.ts

@@ -1,15 +1,15 @@
-import { type apiCreateRegistry, registry } from "@/server/db/schema";
-import { TRPCError } from "@trpc/server";
 import { db } from "@/server/db";
-import { eq } from "drizzle-orm";
-import { findAdmin } from "./admin";
+import { type apiCreateRegistry, registry } from "@/server/db/schema";
+import { initializeRegistry } from "@/server/setup/registry-setup";
+import { removeService } from "@/server/utils/docker/utils";
+import { execAsync } from "@/server/utils/process/execAsync";
 import {
 	manageRegistry,
 	removeSelfHostedRegistry,
 } from "@/server/utils/traefik/registry";
-import { removeService } from "@/server/utils/docker/utils";
-import { initializeRegistry } from "@/server/setup/registry-setup";
-import { execAsync } from "@/server/utils/process/execAsync";
+import { TRPCError } from "@trpc/server";
+import { eq } from "drizzle-orm";
+import { findAdmin } from "./admin";
 
 export type Registry = typeof registry.$inferSelect;
 

server/api/services/security.ts

@@ -1,13 +1,13 @@
 import { db } from "@/server/db";
 import { type apiCreateSecurity, security } from "@/server/db/schema";
-import { TRPCError } from "@trpc/server";
-import { eq } from "drizzle-orm";
-import type { z } from "zod";
-import { findApplicationById } from "./application";
 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) => {

server/api/services/settings.ts

@@ -1,8 +1,8 @@
-import { docker } from "@/server/constants";
-import packageInfo from "../../../package.json";
 import { readdirSync } from "node:fs";
 import { join } from "node:path";
+import { docker } from "@/server/constants";
 import { getServiceContainer } from "@/server/utils/docker/utils";
+import packageInfo from "../../../package.json";
 
 const updateIsAvailable = async () => {
 	try {

server/api/trpc.ts

@@ -9,14 +9,14 @@
 
 // import { getServerAuthSession } from "@/server/auth";
 import { db } from "@/server/db";
+import type { OpenApiMeta } from "@dokploy/trpc-openapi";
 import { TRPCError, initTRPC } from "@trpc/server";
 import type { CreateNextContextOptions } from "@trpc/server/adapters/next";
+import type { Session, User } from "lucia";
 import superjson from "superjson";
 import { ZodError } from "zod";
 import { validateRequest } from "../auth/auth";
-import type { Session, User } from "lucia";
 import { validateBearerToken } from "../auth/token";
-import type { OpenApiMeta } from "@dokploy/trpc-openapi";
 
 /**
  * 1. CONTEXT

server/auth/auth.ts

@@ -1,11 +1,11 @@
-import { Lucia } from "lucia/dist/core.js";
 import { webcrypto } from "node:crypto";
-import { DrizzlePostgreSQLAdapter } from "@lucia-auth/adapter-drizzle";
-import type { Session, User } from "lucia/dist/core.js";
 import type { IncomingMessage, ServerResponse } from "node:http";
-import { auth, type DatabaseUser, sessionTable } from "../db/schema";
-import { db } from "../db";
+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);

server/auth/token.ts

@@ -1,7 +1,7 @@
-import { Lucia } from "lucia/dist/core.js";
 import type { IncomingMessage } from "node:http";
 import { TimeSpan } from "lucia";
-import { adapter, type ReturnValidateToken } from "./auth";
+import { Lucia } from "lucia/dist/core.js";
+import { type ReturnValidateToken, adapter } from "./auth";
 
 export const luciaToken = new Lucia(adapter, {
 	sessionCookie: {

server/constants/index.ts

@@ -1,5 +1,5 @@
-import Docker from "dockerode";
 import path from "node:path";
+import Docker from "dockerode";
 
 export const BASE_PATH =
 	process.env.NODE_ENV === "production"

server/db/index.ts

@@ -1,6 +1,6 @@
-import { drizzle, type PostgresJsDatabase } from "drizzle-orm/postgres-js";
-import * as schema from "./schema";
+import { type PostgresJsDatabase, drizzle } from "drizzle-orm/postgres-js";
 import postgres from "postgres";
+import * as schema from "./schema";
 
 declare global {
 	// eslint-disable-next-line no-var -- only var works here

server/db/reset.ts

@@ -1,6 +1,6 @@
+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 { sql } from "drizzle-orm";
 import postgres from "postgres";
 
 const connectionString = process.env.DATABASE_URL || "";

server/db/schema/admin.ts

@@ -1,12 +1,12 @@
 import { relations } from "drizzle-orm";
 import { boolean, integer, pgTable, text } from "drizzle-orm/pg-core";
-import { nanoid } from "nanoid";
-import { auth } from "./auth";
-import { users } from "./user";
 import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
 import { z } from "zod";
-import { certificateType } from "./shared";
+import { auth } from "./auth";
 import { registry } from "./registry";
+import { certificateType } from "./shared";
+import { users } from "./user";
 
 export const admins = pgTable("admin", {
 	adminId: text("adminId")

server/db/schema/application.ts

@@ -1,15 +1,5 @@
+import { generatePassword } from "@/templates/utils";
 import { relations } from "drizzle-orm";
-import { createInsertSchema } from "drizzle-zod";
-import { z } from "zod";
-import { nanoid } from "nanoid";
-import { deployments } from "./deployment";
-import { mounts } from "./mount";
-import { redirects } from "./redirects";
-import { domains } from "./domain";
-import { projects } from "./project";
-import { security } from "./security";
-import { applicationStatus } from "./shared";
-import { ports } from "./port";
 import {
 	boolean,
 	integer,
@@ -18,9 +8,19 @@ import {
 	pgTable,
 	text,
 } from "drizzle-orm/pg-core";
-import { generateAppName } from "./utils";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { deployments } from "./deployment";
+import { domains } from "./domain";
+import { mounts } from "./mount";
+import { ports } from "./port";
+import { projects } from "./project";
+import { redirects } from "./redirects";
 import { registry } from "./registry";
-import { generatePassword } from "@/templates/utils";
+import { security } from "./security";
+import { applicationStatus } from "./shared";
+import { generateAppName } from "./utils";
 
 export const sourceType = pgEnum("sourceType", ["docker", "git", "github"]);
 

server/db/schema/auth.ts

@@ -1,11 +1,11 @@
-import { relations } from "drizzle-orm";
-import { pgTable, pgEnum, text, boolean } from "drizzle-orm/pg-core";
-import { nanoid } from "nanoid";
-import { users } from "./user";
-import { admins } from "./admin";
-import { createInsertSchema } from "drizzle-zod";
-import { z } from "zod";
 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",

server/db/schema/backups.ts

@@ -1,12 +1,4 @@
 import { relations } from "drizzle-orm";
-import { destinations } from "./destination";
-import { createInsertSchema } from "drizzle-zod";
-import { z } from "zod";
-import { nanoid } from "nanoid";
-import { postgres } from "./postgres";
-import { mariadb } from "./mariadb";
-import { mysql } from "./mysql";
-import { mongo } from "./mongo";
 import {
 	type AnyPgColumn,
 	boolean,
@@ -14,6 +6,14 @@ import {
 	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",

server/db/schema/certificate.ts

@@ -1,7 +1,7 @@
-import { createInsertSchema } from "drizzle-zod";
-import { z } from "zod";
-import { nanoid } from "nanoid";
 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", {

server/db/schema/compose.ts

@@ -1,14 +1,14 @@
-import { createInsertSchema } from "drizzle-zod";
-import { z } from "zod";
-import { nanoid } from "nanoid";
-import { boolean, pgEnum, pgTable, text } from "drizzle-orm/pg-core";
-import { projects } from "./project";
-import { relations } from "drizzle-orm";
-import { deployments } from "./deployment";
-import { generateAppName } from "./utils";
-import { applicationStatus } from "./shared";
-import { mounts } from "./mount";
 import { generatePassword } from "@/templates/utils";
+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 { deployments } from "./deployment";
+import { mounts } from "./mount";
+import { projects } from "./project";
+import { applicationStatus } from "./shared";
+import { generateAppName } from "./utils";
 
 export const sourceTypeCompose = pgEnum("sourceTypeCompose", [
 	"git",

server/db/schema/deployment.ts

@@ -1,9 +1,9 @@
 import { relations } from "drizzle-orm";
-import { z } from "zod";
-import { nanoid } from "nanoid";
-import { applications } from "./application";
-import { createInsertSchema } from "drizzle-zod";
 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";
 
 export const deploymentStatus = pgEnum("deploymentStatus", [

server/db/schema/destination.ts

@@ -1,8 +1,8 @@
 import { relations } from "drizzle-orm";
-import { createInsertSchema } from "drizzle-zod";
-import { z } from "zod";
-import { nanoid } from "nanoid";
 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";
 

server/db/schema/domain.ts

@@ -1,8 +1,8 @@
 import { relations } from "drizzle-orm";
+import { boolean, integer, pgTable, serial, text } from "drizzle-orm/pg-core";
 import { createInsertSchema } from "drizzle-zod";
 import { nanoid } from "nanoid";
 import { z } from "zod";
-import { boolean, integer, pgTable, serial, text } from "drizzle-orm/pg-core";
 import { applications } from "./application";
 import { certificateType } from "./shared";
 

server/db/schema/mariadb.ts

@@ -1,14 +1,14 @@
+import { generatePassword } from "@/templates/utils";
 import { relations } from "drizzle-orm";
-import { createInsertSchema } from "drizzle-zod";
-import { z } from "zod";
-import { nanoid } from "nanoid";
-import { applicationStatus } from "./shared";
 import { integer, pgTable, text } from "drizzle-orm/pg-core";
-import { projects } from "./project";
+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 { applicationStatus } from "./shared";
 import { generateAppName } from "./utils";
-import { generatePassword } from "@/templates/utils";
 
 export const mariadb = pgTable("mariadb", {
 	mariadbId: text("mariadbId")

server/db/schema/mongo.ts

@@ -1,14 +1,14 @@
+import { generatePassword } from "@/templates/utils";
 import { relations } from "drizzle-orm";
-import { createInsertSchema } from "drizzle-zod";
-import { z } from "zod";
-import { nanoid } from "nanoid";
-import { applicationStatus } from "./shared";
 import { integer, pgTable, text } from "drizzle-orm/pg-core";
-import { projects } from "./project";
+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 { applicationStatus } from "./shared";
 import { generateAppName } from "./utils";
-import { generatePassword } from "@/templates/utils";
 
 export const mongo = pgTable("mongo", {
 	mongoId: text("mongoId")

server/db/schema/mount.ts

@@ -1,15 +1,15 @@
-import { nanoid } from "nanoid";
-import { applications } from "./application";
 import { relations } from "drizzle-orm";
-import { createInsertSchema } from "drizzle-zod";
-import { z } from "zod";
 import { pgEnum, pgTable, text } from "drizzle-orm/pg-core";
-import { postgres } from "./postgres";
+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";
-import { compose } from "./compose";
 
 export const serviceType = pgEnum("serviceType", [
 	"application",

server/db/schema/mysql.ts

@@ -1,14 +1,14 @@
+import { generatePassword } from "@/templates/utils";
 import { relations } from "drizzle-orm";
-import { createInsertSchema } from "drizzle-zod";
-import { z } from "zod";
-import { nanoid } from "nanoid";
-import { applicationStatus } from "./shared";
 import { integer, pgTable, text } from "drizzle-orm/pg-core";
-import { projects } from "./project";
+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 { applicationStatus } from "./shared";
 import { generateAppName } from "./utils";
-import { generatePassword } from "@/templates/utils";
 
 export const mysql = pgTable("mysql", {
 	mysqlId: text("mysqlId")

server/db/schema/port.ts

@@ -1,8 +1,8 @@
 import { relations } from "drizzle-orm";
-import { createInsertSchema } from "drizzle-zod";
-import { z } from "zod";
-import { nanoid } from "nanoid";
 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"]);

server/db/schema/postgres.ts

@@ -1,14 +1,14 @@
+import { generatePassword } from "@/templates/utils";
 import { relations } from "drizzle-orm";
-import { createInsertSchema } from "drizzle-zod";
-import { z } from "zod";
-import { nanoid } from "nanoid";
-import { applicationStatus } from "./shared";
 import { integer, pgTable, text } from "drizzle-orm/pg-core";
-import { projects } from "./project";
+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 { applicationStatus } from "./shared";
 import { generateAppName } from "./utils";
-import { generatePassword } from "@/templates/utils";
 
 export const postgres = pgTable("postgres", {
 	postgresId: text("postgresId")

server/db/schema/project.ts

@@ -1,17 +1,17 @@
 import { relations } from "drizzle-orm";
 
-import { createInsertSchema } from "drizzle-zod";
-import { z } from "zod";
-import { nanoid } from "nanoid";
 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 { mariadb } from "./mariadb";
-import { applications } from "./application";
-import { mongo } from "./mongo";
 import { redis } from "./redis";
-import { admins } from "./admin";
-import { compose } from "./compose";
 
 export const projects = pgTable("project", {
 	projectId: text("projectId")

server/db/schema/redirects.ts

@@ -1,8 +1,8 @@
 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 { boolean, pgTable, serial, text } from "drizzle-orm/pg-core";
 import { applications } from "./application";
 
 export const redirects = pgTable("redirect", {

server/db/schema/redis.ts

@@ -1,13 +1,13 @@
+import { generatePassword } from "@/templates/utils";
 import { relations } from "drizzle-orm";
-import { z } from "zod";
+import { integer, pgTable, text } from "drizzle-orm/pg-core";
 import { createInsertSchema } from "drizzle-zod";
 import { nanoid } from "nanoid";
-import { applicationStatus } from "./shared";
-import { integer, pgTable, text } from "drizzle-orm/pg-core";
-import { projects } from "./project";
+import { z } from "zod";
 import { mounts } from "./mount";
+import { projects } from "./project";
+import { applicationStatus } from "./shared";
 import { generateAppName } from "./utils";
-import { generatePassword } from "@/templates/utils";
 
 export const redis = pgTable("redis", {
 	redisId: text("redisId")

server/db/schema/registry.ts

@@ -1,11 +1,11 @@
-import { createInsertSchema } from "drizzle-zod";
-import { nanoid } from "nanoid";
 import { relations, sql } from "drizzle-orm";
 import { boolean, pgEnum, pgTable, text, timestamp } from "drizzle-orm/pg-core";
-import { auth } from "./auth";
-import { admins } from "./admin";
+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.

server/db/schema/security.ts

@@ -1,8 +1,8 @@
 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 { pgTable, text, unique } from "drizzle-orm/pg-core";
 import { applications } from "./application";
 
 export const security = pgTable(

server/db/schema/session.ts

@@ -1,5 +1,5 @@
-import { auth } from "./auth";
 import { pgTable, text, timestamp } from "drizzle-orm/pg-core";
+import { auth } from "./auth";
 
 export const sessionTable = pgTable("session", {
 	id: text("id").primaryKey(),

server/db/schema/source.ts

@@ -1,7 +1,7 @@
-import { createInsertSchema } from "drizzle-zod";
-import { z } from "zod";
-import { nanoid } from "nanoid";
 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")

server/db/schema/user.ts

@@ -1,10 +1,10 @@
-import { createInsertSchema } from "drizzle-zod";
-import { nanoid } from "nanoid";
 import { relations, sql } from "drizzle-orm";
 import { boolean, pgTable, text, timestamp } from "drizzle-orm/pg-core";
-import { auth } from "./auth";
-import { admins } from "./admin";
+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.

server/db/seed.ts

@@ -1,7 +1,7 @@
 import bc from "bcrypt";
-import { users } from "./schema";
 import { drizzle } from "drizzle-orm/postgres-js";
 import postgres from "postgres";
+import { users } from "./schema";
 
 const connectionString = process.env.DATABASE_URL || "";
 

server/monitoring/utilts.ts

@@ -1,7 +1,7 @@
 import { promises } from "node:fs";
-import { MONITORING_PATH } from "../constants";
 import dockerstats from "dockerstats";
 import osUtils from "node-os-utils";
+import { MONITORING_PATH } from "../constants";
 
 export const recordAdvancedStats = async (
 	appName: string,

server/queues/deployments-queue.ts

@@ -4,12 +4,12 @@ import {
 	rebuildApplication,
 	updateApplicationStatus,
 } from "../api/services/application";
-import { myQueue, redisConfig } from "./queueSetup";
 import {
 	deployCompose,
 	rebuildCompose,
 	updateCompose,
 } from "../api/services/compose";
+import { myQueue, redisConfig } from "./queueSetup";
 
 type DeployJob =
 	| {

server/queues/queueSetup.ts

@@ -1,4 +1,4 @@
-import { Queue, type ConnectionOptions } from "bullmq";
+import { type ConnectionOptions, Queue } from "bullmq";
 
 export const redisConfig: ConnectionOptions = {
 	host: process.env.NODE_ENV === "production" ? "dokploy-redis" : "127.0.0.1",

server/server.ts

@@ -1,15 +1,11 @@
 import http from "node:http";
+import { migration } from "@/server/db/migration";
 import { config } from "dotenv";
 import next from "next";
 import { deploymentWorker } from "./queues/deployments-queue";
-import { initCronJobs } from "./utils/backups";
-import {
-	getPublicIpWithFallback,
-	setupTerminalWebSocketServer,
-} from "./wss/terminal";
-import { setupDeploymentLogsWebSocketServer } from "./wss/listen-deployment";
-import { setupDockerStatsMonitoringSocketServer } from "./wss/docker-stats";
 import { setupDirectories } from "./setup/config-paths";
+import { initializePostgres } from "./setup/postgres-setup";
+import { initializeRedis } from "./setup/redis-setup";
 import { initializeNetwork } from "./setup/setup";
 import {
 	createDefaultMiddlewares,
@@ -17,11 +13,15 @@ import {
 	createDefaultTraefikConfig,
 	initializeTraefik,
 } from "./setup/traefik-setup";
-import { initializeRedis } from "./setup/redis-setup";
-import { initializePostgres } from "./setup/postgres-setup";
-import { migration } from "@/server/db/migration";
+import { initCronJobs } from "./utils/backups";
 import { setupDockerContainerLogsWebSocketServer } from "./wss/docker-container-logs";
 import { setupDockerContainerTerminalWebSocketServer } from "./wss/docker-container-terminal";
+import { setupDockerStatsMonitoringSocketServer } from "./wss/docker-stats";
+import { setupDeploymentLogsWebSocketServer } from "./wss/listen-deployment";
+import {
+	getPublicIpWithFallback,
+	setupTerminalWebSocketServer,
+} from "./wss/terminal";
 
 config({ path: ".env" });
 const PORT = Number.parseInt(process.env.PORT || "3000", 10);

server/setup/config-paths.ts

@@ -3,11 +3,11 @@ import {
 	APPLICATIONS_PATH,
 	BASE_PATH,
 	CERTIFICATES_PATH,
+	DYNAMIC_TRAEFIK_PATH,
 	LOGS_PATH,
+	MAIN_TRAEFIK_PATH,
 	MONITORING_PATH,
 	SSH_PATH,
-	DYNAMIC_TRAEFIK_PATH,
-	MAIN_TRAEFIK_PATH,
 } from "../constants";
 
 const createDirectoryIfNotExist = (dirPath: string) => {

server/setup/postgres-setup.ts

@@ -1,6 +1,6 @@
+import type { CreateServiceOptions } from "dockerode";
 import { docker } from "../constants";
 import { pullImage } from "../utils/docker/utils";
-import type { CreateServiceOptions } from "dockerode";
 export const initializePostgres = async () => {
 	const imageName = "postgres:16";
 	const containerName = "dokploy-postgres";

server/setup/registry-setup.ts

@@ -1,8 +1,8 @@
 import type { CreateServiceOptions } from "dockerode";
-import { docker, REGISTRY_PATH } from "../constants";
+import { generateRandomPassword } from "../auth/random-password";
+import { REGISTRY_PATH, docker } from "../constants";
 import { pullImage } from "../utils/docker/utils";
 import { execAsync } from "../utils/process/execAsync";
-import { generateRandomPassword } from "../auth/random-password";
 
 export const initializeRegistry = async (
 	username: string,

server/setup/traefik-setup.ts

@@ -1,11 +1,11 @@
-import path from "node:path";
-import { MAIN_TRAEFIK_PATH, DYNAMIC_TRAEFIK_PATH, docker } from "../constants";
-import { pullImage } from "../utils/docker/utils";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { dump } from "js-yaml";
-import type { MainTraefikConfig } from "../utils/traefik/types";
-import type { FileConfig } from "../utils/traefik/file-types";
+import path from "node:path";
 import type { CreateServiceOptions } from "dockerode";
+import { dump } from "js-yaml";
+import { DYNAMIC_TRAEFIK_PATH, MAIN_TRAEFIK_PATH, docker } from "../constants";
+import { pullImage } from "../utils/docker/utils";
+import type { FileConfig } from "../utils/traefik/file-types";
+import type { MainTraefikConfig } from "../utils/traefik/types";
 
 const TRAEFIK_SSL_PORT =
 	Number.parseInt(process.env.TRAEFIK_SSL_PORT ?? "", 10) || 443;

server/types/with.ts

@@ -1,8 +1,8 @@
 import type * as schema from "@/server/db/schema";
-import {
-  type BuildQueryResult,
-  type DBQueryConfig,
-  type ExtractTablesWithRelations,
+import type {
+	BuildQueryResult,
+	DBQueryConfig,
+	ExtractTablesWithRelations,
 } from "drizzle-orm";
 import { z } from "zod";
 /*
@@ -14,27 +14,27 @@ type Schema = typeof schema;
 type TSchema = ExtractTablesWithRelations<Schema>;
 
 export type IncludeRelation<TableName extends keyof TSchema> = DBQueryConfig<
-  "one" | "many",
-  boolean,
-  TSchema,
-  TSchema[TableName]
+	"one" | "many",
+	boolean,
+	TSchema,
+	TSchema[TableName]
 >["with"];
 
 export type InferResultType<
-  TableName extends keyof TSchema,
-  With extends IncludeRelation<TableName> | undefined = undefined,
+	TableName extends keyof TSchema,
+	With extends IncludeRelation<TableName> | undefined = undefined,
 > = BuildQueryResult<
-  TSchema,
-  TSchema[TableName],
-  {
-    with: With;
-  }
+	TSchema,
+	TSchema[TableName],
+	{
+		with: With;
+	}
 >;
 
 type AnyObj = Record<PropertyKey, unknown>;
 
 type ZodObj<T extends AnyObj> = {
-  [key in keyof T]: z.ZodType<T[key]>;
+	[key in keyof T]: z.ZodType<T[key]>;
 };
 const zObject = <T extends AnyObj>(arg: ZodObj<T>) => z.object(arg);
 

server/utils/backups/index.ts

@@ -1,15 +1,15 @@
+import { findAdmin } from "@/server/api/services/admin";
 import { scheduleJob } from "node-schedule";
 import { db } from "../../db/index";
-import { runMariadbBackup } from "./mariadb";
-import { runMongoBackup } from "./mongo";
-import { runMySqlBackup } from "./mysql";
-import { runPostgresBackup } from "./postgres";
 import {
 	cleanUpDockerBuilder,
 	cleanUpSystemPrune,
 	cleanUpUnusedImages,
 } from "../docker/utils";
-import { findAdmin } from "@/server/api/services/admin";
+import { runMariadbBackup } from "./mariadb";
+import { runMongoBackup } from "./mongo";
+import { runMySqlBackup } from "./mysql";
+import { runPostgresBackup } from "./postgres";
 
 export const initCronJobs = async () => {
 	console.log("Setting up cron jobs....");

server/utils/backups/mariadb.ts

@@ -1,10 +1,10 @@
 import { unlink } from "node:fs/promises";
 import path from "node:path";
-import { execAsync } from "../process/execAsync";
-import { uploadToS3 } from "./utils";
 import type { BackupSchedule } from "@/server/api/services/backup";
 import type { Mariadb } from "@/server/api/services/mariadb";
 import { getServiceContainer } from "../docker/utils";
+import { execAsync } from "../process/execAsync";
+import { uploadToS3 } from "./utils";
 
 export const runMariadbBackup = async (
 	mariadb: Mariadb,

server/utils/backups/mongo.ts

@@ -1,10 +1,10 @@
 import { unlink } from "node:fs/promises";
 import path from "node:path";
-import { execAsync } from "../process/execAsync";
-import { uploadToS3 } from "./utils";
 import type { BackupSchedule } from "@/server/api/services/backup";
 import type { Mongo } from "@/server/api/services/mongo";
 import { getServiceContainer } from "../docker/utils";
+import { execAsync } from "../process/execAsync";
+import { uploadToS3 } from "./utils";
 
 // mongodb://mongo:Bqh7AQl-PRbnBu@localhost:27017/?tls=false&directConnection=true
 export const runMongoBackup = async (mongo: Mongo, backup: BackupSchedule) => {

server/utils/backups/mysql.ts

@@ -1,10 +1,10 @@
-import path from "node:path";
-import { execAsync } from "../process/execAsync";
 import { unlink } from "node:fs/promises";
-import { uploadToS3 } from "./utils";
+import path from "node:path";
 import type { BackupSchedule } from "@/server/api/services/backup";
 import type { MySql } from "@/server/api/services/mysql";
 import { getServiceContainer } from "../docker/utils";
+import { execAsync } from "../process/execAsync";
+import { uploadToS3 } from "./utils";
 
 export const runMySqlBackup = async (mysql: MySql, backup: BackupSchedule) => {
 	const { appName, databaseRootPassword } = mysql;

server/utils/backups/postgres.ts

@@ -1,10 +1,10 @@
-import path from "node:path";
-import { execAsync } from "../process/execAsync";
 import { unlink } from "node:fs/promises";
-import { uploadToS3 } from "./utils";
+import path from "node:path";
 import type { BackupSchedule } from "@/server/api/services/backup";
 import type { Postgres } from "@/server/api/services/postgres";
 import { getServiceContainer } from "../docker/utils";
+import { execAsync } from "../process/execAsync";
+import { uploadToS3 } from "./utils";
 
 export const runPostgresBackup = async (
 	postgres: Postgres,

server/utils/backups/utils.ts

@@ -1,12 +1,12 @@
+import { readFile } from "node:fs/promises";
 import type { BackupSchedule } from "@/server/api/services/backup";
 import type { Destination } from "@/server/api/services/destination";
-import { S3Client, PutObjectCommand } from "@aws-sdk/client-s3";
+import { PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
 import { scheduleJob, scheduledJobs } from "node-schedule";
-import { readFile } from "node:fs/promises";
-import { runPostgresBackup } from "./postgres";
-import { runMySqlBackup } from "./mysql";
-import { runMongoBackup } from "./mongo";
 import { runMariadbBackup } from "./mariadb";
+import { runMongoBackup } from "./mongo";
+import { runMySqlBackup } from "./mysql";
+import { runPostgresBackup } from "./postgres";
 
 export const uploadToS3 = async (
 	destination: Destination,

server/utils/builders/compose.ts

@@ -4,15 +4,15 @@ import {
 	mkdirSync,
 	writeFileSync,
 } from "node:fs";
-import type { InferResultType } from "@/server/types/with";
-import { spawnAsync } from "../process/spawnAsync";
-import { COMPOSE_PATH } from "@/server/constants";
 import { dirname, join } from "node:path";
+import { COMPOSE_PATH } from "@/server/constants";
+import type { InferResultType } from "@/server/types/with";
+import boxen from "boxen";
 import {
 	generateFileMountsCompose,
 	prepareEnvironmentVariables,
 } from "../docker/utils";
-import boxen from "boxen";
+import { spawnAsync } from "../process/spawnAsync";
 
 export type ComposeNested = InferResultType<
 	"compose",

server/utils/builders/docker-file.ts

@@ -1,40 +1,40 @@
-import { docker } from "@/server/constants";
 import type { WriteStream } from "node:fs";
+import { docker } from "@/server/constants";
 import * as tar from "tar-fs";
 import type { ApplicationNested } from ".";
 import { getBuildAppDirectory } from "../filesystem/directory";
 
 export const buildCustomDocker = async (
-  application: ApplicationNested,
-  writeStream: WriteStream,
+	application: ApplicationNested,
+	writeStream: WriteStream,
 ) => {
-  const { appName } = application;
-  const dockerFilePath = getBuildAppDirectory(application);
-  try {
-    const image = `${appName}`;
-    const contextPath =
-      dockerFilePath.substring(0, dockerFilePath.lastIndexOf("/") + 1) || ".";
-    const tarStream = tar.pack(contextPath);
+	const { appName } = application;
+	const dockerFilePath = getBuildAppDirectory(application);
+	try {
+		const image = `${appName}`;
+		const contextPath =
+			dockerFilePath.substring(0, dockerFilePath.lastIndexOf("/") + 1) || ".";
+		const tarStream = tar.pack(contextPath);
 
-    const stream = await docker.buildImage(tarStream, {
-      t: image,
-      dockerfile: dockerFilePath.substring(dockerFilePath.lastIndexOf("/") + 1),
-      // TODO: maybe use or not forcerm
-      // forcerm: true,
-    });
+		const stream = await docker.buildImage(tarStream, {
+			t: image,
+			dockerfile: dockerFilePath.substring(dockerFilePath.lastIndexOf("/") + 1),
+			// TODO: maybe use or not forcerm
+			// forcerm: true,
+		});
 
-    await new Promise((resolve, reject) => {
-      docker.modem.followProgress(
-        stream,
-        (err, res) => (err ? reject(err) : resolve(res)),
-        (event) => {
-          if (event.stream) {
-            writeStream.write(event.stream);
-          }
-        },
-      );
-    });
-  } catch (error) {
-    throw error;
-  }
+		await new Promise((resolve, reject) => {
+			docker.modem.followProgress(
+				stream,
+				(err, res) => (err ? reject(err) : resolve(res)),
+				(event) => {
+					if (event.stream) {
+						writeStream.write(event.stream);
+					}
+				},
+			);
+		});
+	} catch (error) {
+		throw error;
+	}
 };

server/utils/builders/heroku.ts

@@ -1,8 +1,8 @@
+import type { WriteStream } from "node:fs";
 import type { ApplicationNested } from ".";
 import { prepareEnvironmentVariables } from "../docker/utils";
 import { getBuildAppDirectory } from "../filesystem/directory";
 import { spawnAsync } from "../process/spawnAsync";
-import type { WriteStream } from "node:fs";
 
 // TODO: integrate in the vps sudo chown -R $(whoami) ~/.docker
 export const buildHeroku = async (

server/utils/builders/index.ts

@@ -2,6 +2,7 @@ import { createWriteStream } from "node:fs";
 import { docker } from "@/server/constants";
 import type { InferResultType } from "@/server/types/with";
 import type { CreateServiceOptions } from "dockerode";
+import { uploadImage } from "../cluster/upload";
 import {
 	calculateResources,
 	generateBindMounts,
@@ -14,7 +15,6 @@ import { buildCustomDocker } from "./docker-file";
 import { buildHeroku } from "./heroku";
 import { buildNixpacks } from "./nixpacks";
 import { buildPaketo } from "./paketo";
-import { uploadImage } from "../cluster/upload";
 
 // NIXPACKS codeDirectory = where is the path of the code directory
 // HEROKU codeDirectory = where is the path of the code directory

server/utils/builders/nixpacks.ts

@@ -1,8 +1,8 @@
+import type { WriteStream } from "node:fs";
 import type { ApplicationNested } from ".";
 import { prepareEnvironmentVariables } from "../docker/utils";
 import { getBuildAppDirectory } from "../filesystem/directory";
 import { spawnAsync } from "../process/spawnAsync";
-import type { WriteStream } from "node:fs";
 
 // TODO: integrate in the vps sudo chown -R $(whoami) ~/.docker
 export const buildNixpacks = async (

server/utils/builders/paketo.ts

@@ -1,8 +1,8 @@
 import type { WriteStream } from "node:fs";
-import { spawnAsync } from "../process/spawnAsync";
 import type { ApplicationNested } from ".";
-import { getBuildAppDirectory } from "../filesystem/directory";
 import { prepareEnvironmentVariables } from "../docker/utils";
+import { getBuildAppDirectory } from "../filesystem/directory";
+import { spawnAsync } from "../process/spawnAsync";
 
 // TODO: integrate in the vps sudo chown -R $(whoami) ~/.docker
 export const buildPaketo = async (

server/utils/cluster/upload.ts

@@ -1,6 +1,6 @@
+import type { WriteStream } from "node:fs";
 import type { ApplicationNested } from "../builders";
 import { spawnAsync } from "../process/spawnAsync";
-import type { WriteStream } from "node:fs";
 
 export const uploadImage = async (
 	application: ApplicationNested,

server/utils/databases/mariadb.ts

@@ -1,4 +1,5 @@
 import type { Mariadb } from "@/server/api/services/mariadb";
+import type { Mount } from "@/server/api/services/mount";
 import { docker } from "@/server/constants";
 import type { CreateServiceOptions } from "dockerode";
 import {
@@ -8,7 +9,6 @@ import {
 	generateVolumeMounts,
 	prepareEnvironmentVariables,
 } from "../docker/utils";
-import type { Mount } from "@/server/api/services/mount";
 
 type MariadbWithMounts = Mariadb & {
 	mounts: Mount[];

server/utils/databases/mongo.ts

@@ -1,4 +1,6 @@
 import type { Mongo } from "@/server/api/services/mongo";
+import type { Mount } from "@/server/api/services/mount";
+import type { Postgres } from "@/server/api/services/postgres";
 import { docker } from "@/server/constants";
 import type { CreateServiceOptions } from "dockerode";
 import {
@@ -8,8 +10,6 @@ import {
 	generateVolumeMounts,
 	prepareEnvironmentVariables,
 } from "../docker/utils";
-import type { Postgres } from "@/server/api/services/postgres";
-import type { Mount } from "@/server/api/services/mount";
 
 type MongoWithMounts = Mongo & {
 	mounts: Mount[];

server/utils/databases/mysql.ts

@@ -1,4 +1,7 @@
+import type { Mount } from "@/server/api/services/mount";
 import type { MySql } from "@/server/api/services/mysql";
+import { docker } from "@/server/constants";
+import type { CreateServiceOptions } from "dockerode";
 import {
 	calculateResources,
 	generateBindMounts,
@@ -6,9 +9,6 @@ import {
 	generateVolumeMounts,
 	prepareEnvironmentVariables,
 } from "../docker/utils";
-import { docker } from "@/server/constants";
-import type { CreateServiceOptions } from "dockerode";
-import type { Mount } from "@/server/api/services/mount";
 
 type MysqlWithMounts = MySql & {
 	mounts: Mount[];

server/utils/databases/postgres.ts

@@ -1,4 +1,7 @@
+import type { Mount } from "@/server/api/services/mount";
 import type { Postgres } from "@/server/api/services/postgres";
+import { docker } from "@/server/constants";
+import type { CreateServiceOptions } from "dockerode";
 import {
 	calculateResources,
 	generateBindMounts,
@@ -6,9 +9,6 @@ import {
 	generateVolumeMounts,
 	prepareEnvironmentVariables,
 } from "../docker/utils";
-import { docker } from "@/server/constants";
-import type { CreateServiceOptions } from "dockerode";
-import type { Mount } from "@/server/api/services/mount";
 
 type PostgresWithMounts = Postgres & {
 	mounts: Mount[];

server/utils/databases/redis.ts

@@ -1,4 +1,7 @@
+import type { Mount } from "@/server/api/services/mount";
 import type { Redis } from "@/server/api/services/redis";
+import { docker } from "@/server/constants";
+import type { CreateServiceOptions } from "dockerode";
 import {
 	calculateResources,
 	generateBindMounts,
@@ -6,9 +9,6 @@ import {
 	generateVolumeMounts,
 	prepareEnvironmentVariables,
 } from "../docker/utils";
-import { docker } from "@/server/constants";
-import type { CreateServiceOptions } from "dockerode";
-import type { Mount } from "@/server/api/services/mount";
 
 type RedisWithMounts = Redis & {
 	mounts: Mount[];

server/utils/docker/compose.ts

@@ -1,12 +1,12 @@
 import crypto from "node:crypto";
-import type { ComposeSpecification } from "./types";
 import { findComposeById } from "@/server/api/services/compose";
 import { dump, load } from "js-yaml";
-import { addPrefixToAllVolumes } from "./compose/volume";
 import { addPrefixToAllConfigs } from "./compose/configs";
 import { addPrefixToAllNetworks } from "./compose/network";
 import { addPrefixToAllSecrets } from "./compose/secrets";
 import { addPrefixToAllServiceNames } from "./compose/service";
+import { addPrefixToAllVolumes } from "./compose/volume";
+import type { ComposeSpecification } from "./types";
 
 export const generateRandomHash = (): string => {
 	return crypto.randomBytes(4).toString("hex");

server/utils/docker/utils.ts

@@ -3,9 +3,9 @@ import path from "node:path";
 import type { Readable } from "node:stream";
 import { APPLICATIONS_PATH, COMPOSE_PATH, docker } from "@/server/constants";
 import type { ContainerInfo, ResourceRequirements } from "dockerode";
+import { parse } from "dotenv";
 import type { ApplicationNested } from "../builders";
 import { execAsync } from "../process/execAsync";
-import { parse } from "dotenv";
 
 interface RegistryAuth {
 	username: string;

server/utils/filesystem/ssh.ts

@@ -4,59 +4,59 @@ import { SSH_PATH } from "@/server/constants";
 import { spawnAsync } from "../process/spawnAsync";
 
 export const generateSSHKey = async (appName: string) => {
-  const applicationDirectory = SSH_PATH;
+	const applicationDirectory = SSH_PATH;
 
-  if (!fs.existsSync(applicationDirectory)) {
-    fs.mkdirSync(applicationDirectory, { recursive: true });
-  }
+	if (!fs.existsSync(applicationDirectory)) {
+		fs.mkdirSync(applicationDirectory, { recursive: true });
+	}
 
-  const keyPath = path.join(applicationDirectory, `${appName}_rsa`);
+	const keyPath = path.join(applicationDirectory, `${appName}_rsa`);
 
-  if (fs.existsSync(`${keyPath}`)) {
-    fs.unlinkSync(`${keyPath}`);
-  }
-  if (fs.existsSync(`${keyPath}.pub`)) {
-    fs.unlinkSync(`${keyPath}.pub`);
-  }
-  const args = [
-    "-t",
-    "rsa",
-    "-b",
-    "4096",
-    "-C",
-    "dokploy",
-    "-f",
-    keyPath,
-    "-N",
-    "",
-  ];
-  try {
-    await spawnAsync("ssh-keygen", args);
-    return keyPath;
-  } catch (error) {
-    throw error;
-  }
+	if (fs.existsSync(`${keyPath}`)) {
+		fs.unlinkSync(`${keyPath}`);
+	}
+	if (fs.existsSync(`${keyPath}.pub`)) {
+		fs.unlinkSync(`${keyPath}.pub`);
+	}
+	const args = [
+		"-t",
+		"rsa",
+		"-b",
+		"4096",
+		"-C",
+		"dokploy",
+		"-f",
+		keyPath,
+		"-N",
+		"",
+	];
+	try {
+		await spawnAsync("ssh-keygen", args);
+		return keyPath;
+	} catch (error) {
+		throw error;
+	}
 };
 export const readRSAFile = async (appName: string) => {
-  try {
-    if (!fs.existsSync(SSH_PATH)) {
-      fs.mkdirSync(SSH_PATH, { recursive: true });
-    }
-    const keyPath = path.join(SSH_PATH, `${appName}_rsa.pub`);
-    const data = fs.readFileSync(keyPath, { encoding: "utf-8" });
-    return data;
-  } catch (error) {
-    throw error;
-  }
+	try {
+		if (!fs.existsSync(SSH_PATH)) {
+			fs.mkdirSync(SSH_PATH, { recursive: true });
+		}
+		const keyPath = path.join(SSH_PATH, `${appName}_rsa.pub`);
+		const data = fs.readFileSync(keyPath, { encoding: "utf-8" });
+		return data;
+	} catch (error) {
+		throw error;
+	}
 };
 
 export const removeRSAFiles = async (appName: string) => {
-  try {
-    const publicKeyPath = path.join(SSH_PATH, `${appName}_rsa.pub`);
-    const privateKeyPath = path.join(SSH_PATH, `${appName}_rsa`);
-    await fs.promises.unlink(publicKeyPath);
-    await fs.promises.unlink(privateKeyPath);
-  } catch (error) {
-    throw error;
-  }
+	try {
+		const publicKeyPath = path.join(SSH_PATH, `${appName}_rsa.pub`);
+		const privateKeyPath = path.join(SSH_PATH, `${appName}_rsa`);
+		await fs.promises.unlink(publicKeyPath);
+		await fs.promises.unlink(privateKeyPath);
+	} catch (error) {
+		throw error;
+	}
 };

server/utils/providers/github.ts

@@ -1,12 +1,12 @@
 import { createWriteStream } from "node:fs";
 import { join } from "node:path";
+import type { Admin } from "@/server/api/services/admin";
 import { APPLICATIONS_PATH, COMPOSE_PATH } from "@/server/constants";
 import { createAppAuth } from "@octokit/auth-app";
 import { TRPCError } from "@trpc/server";
 import { Octokit } from "octokit";
 import { recreateDirectory } from "../filesystem/directory";
 import { spawnAsync } from "../process/spawnAsync";
-import type { Admin } from "@/server/api/services/admin";
 
 export const authGithub = (admin: Admin) => {
 	if (!haveGithubRequirements(admin)) {

server/utils/providers/raw.ts

@@ -1,9 +1,9 @@
+import { createWriteStream } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
 import type { Compose } from "@/server/api/services/compose";
 import { COMPOSE_PATH } from "@/server/constants";
-import { createWriteStream } from "node:fs";
-import { join } from "node:path";
 import { recreateDirectory } from "../filesystem/directory";
-import { writeFile } from "node:fs/promises";
 
 export const createComposeFile = async (compose: Compose, logPath: string) => {
 	const { appName, composeFile } = compose;

server/utils/traefik/domain.ts

@@ -1,11 +1,11 @@
+import type { Domain } from "@/server/api/services/domain";
+import type { ApplicationNested } from "../builders";
 import {
 	createServiceConfig,
 	loadOrCreateConfig,
 	removeTraefikConfig,
 	writeTraefikConfig,
 } from "./application";
-import type { ApplicationNested } from "../builders";
-import type { Domain } from "@/server/api/services/domain";
 import type { FileConfig, HttpRouter } from "./file-types";
 
 export const manageDomain = async (app: ApplicationNested, domain: Domain) => {

server/utils/traefik/middleware.ts

@@ -1,7 +1,7 @@
-import { dump, load } from "js-yaml";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { DYNAMIC_TRAEFIK_PATH } from "@/server/constants";
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { dump, load } from "js-yaml";
 import type { ApplicationNested } from "../builders";
 import type { FileConfig } from "./file-types";