refactor: rename builders to server

2025-06-26 18:27:59 +00:00 · 2024-10-05 22:15:47 -06:00
parent 43555cdabe
commit f3ce69b656
361 changed files with 551 additions and 562 deletions
--- a/packages/server/src/db/drizzle.config.ts
+++ b/packages/server/src/db/drizzle.config.ts
@@ -0,0 +1,14 @@
+import { defineConfig } from "drizzle-kit";
+
+export default defineConfig({
+	schema: "./server/db/schema/index.ts",
+	dialect: "postgresql",
+	dbCredentials: {
+		url: process.env.DATABASE_URL || "",
+	},
+	out: "drizzle",
+	migrations: {
+		table: "migrations",
+		schema: "public",
+	},
+});
--- a/packages/server/src/db/index.ts
+++ b/packages/server/src/db/index.ts
@@ -0,0 +1,20 @@
+import { type PostgresJsDatabase, drizzle } from "drizzle-orm/postgres-js";
+import postgres from "postgres";
+import * as schema from "./schema";
+declare global {
+	var db: PostgresJsDatabase<typeof schema> | undefined;
+}
+
+export let db: PostgresJsDatabase<typeof schema>;
+if (process.env.NODE_ENV === "production") {
+	db = drizzle(postgres(process.env.DATABASE_URL || ""), {
+		schema,
+	});
+} else {
+	if (!global.db)
+		global.db = drizzle(postgres(process.env.DATABASE_URL || ""), {
+			schema,
+		});
+
+	db = global.db;
+}
--- a/packages/server/src/db/migration.ts
+++ b/packages/server/src/db/migration.ts
@@ -0,0 +1,21 @@
+// import { drizzle } from "drizzle-orm/postgres-js";
+// import { migrate } from "drizzle-orm/postgres-js/migrator";
+// import postgres from "postgres";
+
+// const connectionString = process.env.DATABASE_URL || "";
+
+// const sql = postgres(connectionString, { max: 1 });
+// const db = drizzle(sql);
+
+// export const migration = async () =>
+// 	await migrate(db, { migrationsFolder: "drizzle" })
+// 		.then(() => {
+// 			console.log("Migration complete");
+// 			sql.end();
+// 		})
+// 		.catch((error) => {
+// 			console.log("Migration failed", error);
+// 		})
+// 		.finally(() => {
+// 			sql.end();
+// 		});
--- a/packages/server/src/db/reset.ts
+++ b/packages/server/src/db/reset.ts
@@ -0,0 +1,23 @@
+// 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 postgres from "postgres";
+
+// const connectionString = process.env.DATABASE_URL || "";
+
+// const pg = postgres(connectionString, { max: 1 });
+// const db = drizzle(pg);
+
+// const clearDb = async (): Promise<void> => {
+// 	try {
+// 		const tablesQuery = sql<string>`DROP SCHEMA public CASCADE; CREATE SCHEMA public; DROP schema drizzle CASCADE;`;
+// 		const tables = await db.execute(tablesQuery);
+// 		console.log(tables);
+// 		await pg.end();
+// 	} catch (error) {
+// 		console.error("Error to clean database", error);
+// 	} finally {
+// 	}
+// };
+
+// clearDb();
--- a/packages/server/src/db/schema/admin.ts
+++ b/packages/server/src/db/schema/admin.ts
@@ -0,0 +1,108 @@
+import { relations } from "drizzle-orm";
+import { boolean, pgTable, text } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { auth } from "./auth";
+import { registry } from "./registry";
+import { certificateType } from "./shared";
+import { sshKeys } from "./ssh-key";
+import { users } from "./user";
+
+export const admins = pgTable("admin", {
+	adminId: text("adminId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	serverIp: text("serverIp"),
+	certificateType: certificateType("certificateType").notNull().default("none"),
+	host: text("host"),
+	letsEncryptEmail: text("letsEncryptEmail"),
+	sshPrivateKey: text("sshPrivateKey"),
+	enableDockerCleanup: boolean("enableDockerCleanup").notNull().default(false),
+	enableLogRotation: boolean("enableLogRotation").notNull().default(false),
+	authId: text("authId")
+		.notNull()
+		.references(() => auth.id, { onDelete: "cascade" }),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+});
+
+export const adminsRelations = relations(admins, ({ one, many }) => ({
+	auth: one(auth, {
+		fields: [admins.authId],
+		references: [auth.id],
+	}),
+	users: many(users),
+	registry: many(registry),
+	sshKeys: many(sshKeys),
+}));
+
+const createSchema = createInsertSchema(admins, {
+	adminId: z.string(),
+	enableDockerCleanup: z.boolean().optional(),
+	sshPrivateKey: z.string().optional(),
+	certificateType: z.enum(["letsencrypt", "none"]).default("none"),
+	serverIp: z.string().optional(),
+});
+
+export const apiSaveSSHKey = createSchema
+	.pick({
+		sshPrivateKey: true,
+	})
+	.required();
+
+export const apiAssignDomain = createSchema
+	.pick({
+		letsEncryptEmail: true,
+		host: true,
+		certificateType: true,
+	})
+	.required();
+
+export const apiUpdateDockerCleanup = createSchema
+	.pick({
+		enableDockerCleanup: true,
+	})
+	.required()
+	.extend({
+		serverId: z.string().optional(),
+	});
+
+export const apiTraefikConfig = z.object({
+	traefikConfig: z.string().min(1),
+});
+
+export const apiModifyTraefikConfig = z.object({
+	path: z.string().min(1),
+	traefikConfig: z.string().min(1),
+	serverId: z.string().optional(),
+});
+export const apiReadTraefikConfig = z.object({
+	path: z.string().min(1),
+	serverId: z.string().optional(),
+});
+
+export const apiEnableDashboard = z.object({
+	enableDashboard: z.boolean().optional(),
+	serverId: z.string().optional(),
+});
+
+export const apiServerSchema = z
+	.object({
+		serverId: z.string().optional(),
+	})
+	.optional();
+
+export const apiReadStatsLogs = z.object({
+	page: z
+		.object({
+			pageIndex: z.number(),
+			pageSize: z.number(),
+		})
+		.optional(),
+	status: z.string().array().optional(),
+	search: z.string().optional(),
+	sort: z.object({ id: z.string(), desc: z.boolean() }).optional(),
+});
--- a/packages/server/src/db/schema/application.ts
+++ b/packages/server/src/db/schema/application.ts
@@ -0,0 +1,490 @@
+import { relations } from "drizzle-orm";
+import {
+	boolean,
+	integer,
+	json,
+	pgEnum,
+	pgTable,
+	text,
+} from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { bitbucket } from "./bitbucket";
+import { deployments } from "./deployment";
+import { domains } from "./domain";
+import { github } from "./github";
+import { gitlab } from "./gitlab";
+import { mounts } from "./mount";
+import { ports } from "./port";
+import { projects } from "./project";
+import { redirects } from "./redirects";
+import { registry } from "./registry";
+import { security } from "./security";
+import { server } from "./server";
+import { applicationStatus } from "./shared";
+import { sshKeys } from "./ssh-key";
+import { generateAppName } from "./utils";
+
+export const sourceType = pgEnum("sourceType", [
+	"docker",
+	"git",
+	"github",
+	"gitlab",
+	"bitbucket",
+	"drop",
+]);
+
+export const buildType = pgEnum("buildType", [
+	"dockerfile",
+	"heroku_buildpacks",
+	"paketo_buildpacks",
+	"nixpacks",
+	"static",
+]);
+
+// TODO: refactor this types
+export interface HealthCheckSwarm {
+	Test?: string[] | undefined;
+	Interval?: number | undefined;
+	Timeout?: number | undefined;
+	StartPeriod?: number | undefined;
+	Retries?: number | undefined;
+}
+
+export interface RestartPolicySwarm {
+	Condition?: string | undefined;
+	Delay?: number | undefined;
+	MaxAttempts?: number | undefined;
+	Window?: number | undefined;
+}
+
+export interface PlacementSwarm {
+	Constraints?: string[] | undefined;
+	Preferences?: Array<{ Spread: { SpreadDescriptor: string } }> | undefined;
+	MaxReplicas?: number | undefined;
+	Platforms?:
+		| Array<{
+				Architecture: string;
+				OS: string;
+		  }>
+		| undefined;
+}
+
+export interface UpdateConfigSwarm {
+	Parallelism: number;
+	Delay?: number | undefined;
+	FailureAction?: string | undefined;
+	Monitor?: number | undefined;
+	MaxFailureRatio?: number | undefined;
+	Order: string;
+}
+
+export interface ServiceModeSwarm {
+	Replicated?: { Replicas?: number | undefined } | undefined;
+	Global?: {} | undefined;
+	ReplicatedJob?:
+		| {
+				MaxConcurrent?: number | undefined;
+				TotalCompletions?: number | undefined;
+		  }
+		| undefined;
+	GlobalJob?: {} | undefined;
+}
+
+export interface NetworkSwarm {
+	Target?: string | undefined;
+	Aliases?: string[] | undefined;
+	DriverOpts?: { [key: string]: string } | undefined;
+}
+
+export interface LabelsSwarm {
+	[name: string]: string;
+}
+
+export const applications = pgTable("application", {
+	applicationId: text("applicationId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	name: text("name").notNull(),
+	appName: text("appName")
+		.notNull()
+		.$defaultFn(() => generateAppName("app"))
+		.unique(),
+	description: text("description"),
+	env: text("env"),
+	buildArgs: text("buildArgs"),
+	memoryReservation: integer("memoryReservation"),
+	memoryLimit: integer("memoryLimit"),
+	cpuReservation: integer("cpuReservation"),
+	cpuLimit: integer("cpuLimit"),
+	title: text("title"),
+	enabled: boolean("enabled"),
+	subtitle: text("subtitle"),
+	command: text("command"),
+	refreshToken: text("refreshToken").$defaultFn(() => nanoid()),
+	sourceType: sourceType("sourceType").notNull().default("github"),
+	// Github
+	repository: text("repository"),
+	owner: text("owner"),
+	branch: text("branch"),
+	buildPath: text("buildPath").default("/"),
+	autoDeploy: boolean("autoDeploy").$defaultFn(() => true),
+	// Gitlab
+	gitlabProjectId: integer("gitlabProjectId"),
+	gitlabRepository: text("gitlabRepository"),
+	gitlabOwner: text("gitlabOwner"),
+	gitlabBranch: text("gitlabBranch"),
+	gitlabBuildPath: text("gitlabBuildPath").default("/"),
+	gitlabPathNamespace: text("gitlabPathNamespace"),
+	// Bitbucket
+	bitbucketRepository: text("bitbucketRepository"),
+	bitbucketOwner: text("bitbucketOwner"),
+	bitbucketBranch: text("bitbucketBranch"),
+	bitbucketBuildPath: text("bitbucketBuildPath").default("/"),
+	// Docker
+	username: text("username"),
+	password: text("password"),
+	dockerImage: text("dockerImage"),
+	// Git
+	customGitUrl: text("customGitUrl"),
+	customGitBranch: text("customGitBranch"),
+	customGitBuildPath: text("customGitBuildPath"),
+	customGitSSHKeyId: text("customGitSSHKeyId").references(
+		() => sshKeys.sshKeyId,
+		{
+			onDelete: "set null",
+		},
+	),
+	dockerfile: text("dockerfile"),
+	dockerContextPath: text("dockerContextPath"),
+	dockerBuildStage: text("dockerBuildStage"),
+	// Drop
+	dropBuildPath: text("dropBuildPath"),
+	// Docker swarm json
+	healthCheckSwarm: json("healthCheckSwarm").$type<HealthCheckSwarm>(),
+	restartPolicySwarm: json("restartPolicySwarm").$type<RestartPolicySwarm>(),
+	placementSwarm: json("placementSwarm").$type<PlacementSwarm>(),
+	updateConfigSwarm: json("updateConfigSwarm").$type<UpdateConfigSwarm>(),
+	rollbackConfigSwarm: json("rollbackConfigSwarm").$type<UpdateConfigSwarm>(),
+	modeSwarm: json("modeSwarm").$type<ServiceModeSwarm>(),
+	labelsSwarm: json("labelsSwarm").$type<LabelsSwarm>(),
+	networkSwarm: json("networkSwarm").$type<NetworkSwarm[]>(),
+	//
+	replicas: integer("replicas").default(1).notNull(),
+	applicationStatus: applicationStatus("applicationStatus")
+		.notNull()
+		.default("idle"),
+	buildType: buildType("buildType").notNull().default("nixpacks"),
+	publishDirectory: text("publishDirectory"),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+	registryId: text("registryId").references(() => registry.registryId, {
+		onDelete: "set null",
+	}),
+	projectId: text("projectId")
+		.notNull()
+		.references(() => projects.projectId, { onDelete: "cascade" }),
+	githubId: text("githubId").references(() => github.githubId, {
+		onDelete: "set null",
+	}),
+	gitlabId: text("gitlabId").references(() => gitlab.gitlabId, {
+		onDelete: "set null",
+	}),
+	bitbucketId: text("bitbucketId").references(() => bitbucket.bitbucketId, {
+		onDelete: "set null",
+	}),
+	serverId: text("serverId").references(() => server.serverId, {
+		onDelete: "cascade",
+	}),
+});
+
+export const applicationsRelations = relations(
+	applications,
+	({ one, many }) => ({
+		project: one(projects, {
+			fields: [applications.projectId],
+			references: [projects.projectId],
+		}),
+		deployments: many(deployments),
+		customGitSSHKey: one(sshKeys, {
+			fields: [applications.customGitSSHKeyId],
+			references: [sshKeys.sshKeyId],
+		}),
+		domains: many(domains),
+		mounts: many(mounts),
+		redirects: many(redirects),
+		security: many(security),
+		ports: many(ports),
+		registry: one(registry, {
+			fields: [applications.registryId],
+			references: [registry.registryId],
+		}),
+		github: one(github, {
+			fields: [applications.githubId],
+			references: [github.githubId],
+		}),
+		gitlab: one(gitlab, {
+			fields: [applications.gitlabId],
+			references: [gitlab.gitlabId],
+		}),
+		bitbucket: one(bitbucket, {
+			fields: [applications.bitbucketId],
+			references: [bitbucket.bitbucketId],
+		}),
+		server: one(server, {
+			fields: [applications.serverId],
+			references: [server.serverId],
+		}),
+	}),
+);
+
+const HealthCheckSwarmSchema = z
+	.object({
+		Test: z.array(z.string()).optional(),
+		Interval: z.number().optional(),
+		Timeout: z.number().optional(),
+		StartPeriod: z.number().optional(),
+		Retries: z.number().optional(),
+	})
+	.strict();
+
+const RestartPolicySwarmSchema = z
+	.object({
+		Condition: z.string().optional(),
+		Delay: z.number().optional(),
+		MaxAttempts: z.number().optional(),
+		Window: z.number().optional(),
+	})
+	.strict();
+
+const PreferenceSchema = z
+	.object({
+		Spread: z.object({
+			SpreadDescriptor: z.string(),
+		}),
+	})
+	.strict();
+
+const PlatformSchema = z
+	.object({
+		Architecture: z.string(),
+		OS: z.string(),
+	})
+	.strict();
+
+const PlacementSwarmSchema = z
+	.object({
+		Constraints: z.array(z.string()).optional(),
+		Preferences: z.array(PreferenceSchema).optional(),
+		MaxReplicas: z.number().optional(),
+		Platforms: z.array(PlatformSchema).optional(),
+	})
+	.strict();
+
+const UpdateConfigSwarmSchema = z
+	.object({
+		Parallelism: z.number(),
+		Delay: z.number().optional(),
+		FailureAction: z.string().optional(),
+		Monitor: z.number().optional(),
+		MaxFailureRatio: z.number().optional(),
+		Order: z.string(),
+	})
+	.strict();
+
+const ReplicatedSchema = z
+	.object({
+		Replicas: z.number().optional(),
+	})
+	.strict();
+
+const ReplicatedJobSchema = z
+	.object({
+		MaxConcurrent: z.number().optional(),
+		TotalCompletions: z.number().optional(),
+	})
+	.strict();
+
+const ServiceModeSwarmSchema = z
+	.object({
+		Replicated: ReplicatedSchema.optional(),
+		Global: z.object({}).optional(),
+		ReplicatedJob: ReplicatedJobSchema.optional(),
+		GlobalJob: z.object({}).optional(),
+	})
+	.strict();
+
+const NetworkSwarmSchema = z.array(
+	z
+		.object({
+			Target: z.string().optional(),
+			Aliases: z.array(z.string()).optional(),
+			DriverOpts: z.object({}).optional(),
+		})
+		.strict(),
+);
+
+const LabelsSwarmSchema = z.record(z.string());
+
+const createSchema = createInsertSchema(applications, {
+	appName: z.string(),
+	createdAt: z.string(),
+	applicationId: z.string(),
+	autoDeploy: z.boolean(),
+	env: z.string().optional(),
+	buildArgs: z.string().optional(),
+	name: z.string().min(1),
+	description: z.string().optional(),
+	memoryReservation: z.number().optional(),
+	memoryLimit: z.number().optional(),
+	cpuReservation: z.number().optional(),
+	cpuLimit: z.number().optional(),
+	title: z.string().optional(),
+	enabled: z.boolean().optional(),
+	subtitle: z.string().optional(),
+	dockerImage: z.string().optional(),
+	username: z.string().optional(),
+	password: z.string().optional(),
+	customGitSSHKeyId: z.string().optional(),
+	repository: z.string().optional(),
+	dockerfile: z.string().optional(),
+	branch: z.string().optional(),
+	customGitBranch: z.string().optional(),
+	customGitBuildPath: z.string().optional(),
+	customGitUrl: z.string().optional(),
+	buildPath: z.string().optional(),
+	projectId: z.string(),
+	sourceType: z.enum(["github", "docker", "git"]).optional(),
+	applicationStatus: z.enum(["idle", "running", "done", "error"]),
+	buildType: z.enum([
+		"dockerfile",
+		"heroku_buildpacks",
+		"paketo_buildpacks",
+		"nixpacks",
+		"static",
+	]),
+	publishDirectory: z.string().optional(),
+	owner: z.string(),
+	healthCheckSwarm: HealthCheckSwarmSchema.nullable(),
+	restartPolicySwarm: RestartPolicySwarmSchema.nullable(),
+	placementSwarm: PlacementSwarmSchema.nullable(),
+	updateConfigSwarm: UpdateConfigSwarmSchema.nullable(),
+	rollbackConfigSwarm: UpdateConfigSwarmSchema.nullable(),
+	modeSwarm: ServiceModeSwarmSchema.nullable(),
+	labelsSwarm: LabelsSwarmSchema.nullable(),
+	networkSwarm: NetworkSwarmSchema.nullable(),
+});
+
+export const apiCreateApplication = createSchema.pick({
+	name: true,
+	appName: true,
+	description: true,
+	projectId: true,
+	serverId: true,
+});
+
+export const apiFindOneApplication = createSchema
+	.pick({
+		applicationId: true,
+	})
+	.required();
+
+export const apiReloadApplication = createSchema
+	.pick({
+		appName: true,
+		applicationId: true,
+	})
+	.required();
+
+export const apiSaveBuildType = createSchema
+	.pick({
+		applicationId: true,
+		buildType: true,
+		dockerfile: true,
+		dockerContextPath: true,
+		dockerBuildStage: true,
+	})
+	.required()
+	.merge(createSchema.pick({ publishDirectory: true }));
+
+export const apiSaveGithubProvider = createSchema
+	.pick({
+		applicationId: true,
+		repository: true,
+		branch: true,
+		owner: true,
+		buildPath: true,
+		githubId: true,
+	})
+	.required();
+
+export const apiSaveGitlabProvider = createSchema
+	.pick({
+		applicationId: true,
+		gitlabBranch: true,
+		gitlabBuildPath: true,
+		gitlabOwner: true,
+		gitlabRepository: true,
+		gitlabId: true,
+		gitlabProjectId: true,
+		gitlabPathNamespace: true,
+	})
+	.required();
+
+export const apiSaveBitbucketProvider = createSchema
+	.pick({
+		bitbucketBranch: true,
+		bitbucketBuildPath: true,
+		bitbucketOwner: true,
+		bitbucketRepository: true,
+		bitbucketId: true,
+		applicationId: true,
+	})
+	.required();
+
+export const apiSaveDockerProvider = createSchema
+	.pick({
+		dockerImage: true,
+		applicationId: true,
+		username: true,
+		password: true,
+	})
+	.required();
+
+export const apiSaveGitProvider = createSchema
+	.pick({
+		customGitBranch: true,
+		applicationId: true,
+		customGitBuildPath: true,
+		customGitUrl: true,
+	})
+	.required()
+	.merge(
+		createSchema.pick({
+			customGitSSHKeyId: true,
+		}),
+	);
+
+export const apiSaveEnvironmentVariables = createSchema
+	.pick({
+		applicationId: true,
+		env: true,
+		buildArgs: true,
+	})
+	.required();
+
+export const apiFindMonitoringStats = createSchema
+	.pick({
+		appName: true,
+	})
+	.required();
+
+export const apiUpdateApplication = createSchema
+	.partial()
+	.extend({
+		applicationId: z.string().min(1),
+	})
+	.omit({ serverId: true });
--- a/packages/server/src/db/schema/auth.ts
+++ b/packages/server/src/db/schema/auth.ts
@@ -0,0 +1,125 @@
+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",
+	"/avatars/avatar-2.png",
+	"/avatars/avatar-3.png",
+	"/avatars/avatar-4.png",
+	"/avatars/avatar-5.png",
+	"/avatars/avatar-6.png",
+	"/avatars/avatar-7.png",
+	"/avatars/avatar-8.png",
+	"/avatars/avatar-9.png",
+	"/avatars/avatar-10.png",
+	"/avatars/avatar-11.png",
+	"/avatars/avatar-12.png",
+];
+
+const generateRandomImage = () => {
+	return (
+		randomImages[
+			// @ts-ignore
+			getRandomValues(new Uint32Array(1))[0] % randomImages.length
+		] || "/avatars/avatar-1.png"
+	);
+};
+export type DatabaseUser = typeof auth.$inferSelect;
+export const roles = pgEnum("Roles", ["admin", "user"]);
+
+export const auth = pgTable("auth", {
+	id: text("id")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	email: text("email").notNull().unique(),
+	password: text("password").notNull(),
+	rol: roles("rol").notNull(),
+	image: text("image").$defaultFn(() => generateRandomImage()),
+	secret: text("secret"),
+	token: text("token"),
+	is2FAEnabled: boolean("is2FAEnabled").notNull().default(false),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+});
+
+export const authRelations = relations(auth, ({ many }) => ({
+	admins: many(admins),
+	users: many(users),
+}));
+const createSchema = createInsertSchema(auth, {
+	email: z.string().email(),
+	password: z.string().min(8),
+	rol: z.enum(["admin", "user"]),
+	image: z.string().optional(),
+});
+
+export const apiCreateAdmin = createSchema.pick({
+	email: true,
+	password: true,
+});
+
+export const apiCreateUser = createSchema
+	.pick({
+		password: true,
+		id: true,
+		token: true,
+	})
+	.required()
+	.extend({
+		token: z.string().min(1),
+	});
+
+export const apiLogin = createSchema
+	.pick({
+		email: true,
+		password: true,
+	})
+	.required();
+
+export const apiUpdateAuth = createSchema.partial().extend({
+	email: z.string().nullable(),
+	password: z.string().nullable(),
+	image: z.string().optional(),
+});
+
+export const apiUpdateAuthByAdmin = createSchema.partial().extend({
+	email: z.string().nullable(),
+	password: z.string().nullable(),
+	image: z.string().optional(),
+	id: z.string().min(1),
+});
+
+export const apiFindOneAuth = createSchema
+	.pick({
+		id: true,
+	})
+	.required();
+
+export const apiVerify2FA = createSchema
+	.extend({
+		pin: z.string().min(6),
+		secret: z.string().min(1),
+	})
+	.pick({
+		pin: true,
+		secret: true,
+	})
+	.required();
+
+export const apiVerifyLogin2FA = createSchema
+	.extend({
+		pin: z.string().min(6),
+	})
+	.pick({
+		pin: true,
+		id: true,
+	})
+	.required();
--- a/packages/server/src/db/schema/backups.ts
+++ b/packages/server/src/db/schema/backups.ts
@@ -0,0 +1,131 @@
+import { relations } from "drizzle-orm";
+import {
+	type AnyPgColumn,
+	boolean,
+	pgEnum,
+	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",
+	"mariadb",
+	"mysql",
+	"mongo",
+]);
+
+export const backups = pgTable("backup", {
+	backupId: text("backupId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	schedule: text("schedule").notNull(),
+	enabled: boolean("enabled"),
+	database: text("database").notNull(),
+	prefix: text("prefix").notNull(),
+
+	destinationId: text("destinationId")
+		.notNull()
+		.references(() => destinations.destinationId, { onDelete: "cascade" }),
+
+	databaseType: databaseType("databaseType").notNull(),
+	postgresId: text("postgresId").references(
+		(): AnyPgColumn => postgres.postgresId,
+		{
+			onDelete: "cascade",
+		},
+	),
+	mariadbId: text("mariadbId").references(
+		(): AnyPgColumn => mariadb.mariadbId,
+		{
+			onDelete: "cascade",
+		},
+	),
+	mysqlId: text("mysqlId").references((): AnyPgColumn => mysql.mysqlId, {
+		onDelete: "cascade",
+	}),
+	mongoId: text("mongoId").references((): AnyPgColumn => mongo.mongoId, {
+		onDelete: "cascade",
+	}),
+});
+
+export const backupsRelations = relations(backups, ({ one }) => ({
+	destination: one(destinations, {
+		fields: [backups.destinationId],
+		references: [destinations.destinationId],
+	}),
+	postgres: one(postgres, {
+		fields: [backups.postgresId],
+		references: [postgres.postgresId],
+	}),
+	mariadb: one(mariadb, {
+		fields: [backups.mariadbId],
+		references: [mariadb.mariadbId],
+	}),
+	mysql: one(mysql, {
+		fields: [backups.mysqlId],
+		references: [mysql.mysqlId],
+	}),
+	mongo: one(mongo, {
+		fields: [backups.mongoId],
+		references: [mongo.mongoId],
+	}),
+}));
+
+const createSchema = createInsertSchema(backups, {
+	backupId: z.string(),
+	destinationId: z.string(),
+	enabled: z.boolean().optional(),
+	prefix: z.string().min(1),
+	database: z.string().min(1),
+	schedule: z.string(),
+	databaseType: z.enum(["postgres", "mariadb", "mysql", "mongo"]),
+	postgresId: z.string().optional(),
+	mariadbId: z.string().optional(),
+	mysqlId: z.string().optional(),
+	mongoId: z.string().optional(),
+});
+
+export const apiCreateBackup = createSchema.pick({
+	schedule: true,
+	enabled: true,
+	prefix: true,
+	destinationId: true,
+	database: true,
+	mariadbId: true,
+	mysqlId: true,
+	postgresId: true,
+	mongoId: true,
+	databaseType: true,
+});
+
+export const apiFindOneBackup = createSchema
+	.pick({
+		backupId: true,
+	})
+	.required();
+
+export const apiRemoveBackup = createSchema
+	.pick({
+		backupId: true,
+	})
+	.required();
+
+export const apiUpdateBackup = createSchema
+	.pick({
+		schedule: true,
+		enabled: true,
+		prefix: true,
+		backupId: true,
+		destinationId: true,
+		database: true,
+	})
+	.required();
--- a/packages/server/src/db/schema/bitbucket.ts
+++ b/packages/server/src/db/schema/bitbucket.ts
@@ -0,0 +1,65 @@
+import { relations } from "drizzle-orm";
+import { pgTable, text } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { gitProvider } from "./git-provider";
+
+export const bitbucket = pgTable("bitbucket", {
+	bitbucketId: text("bitbucketId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	bitbucketUsername: text("bitbucketUsername"),
+	appPassword: text("appPassword"),
+	bitbucketWorkspaceName: text("bitbucketWorkspaceName"),
+	gitProviderId: text("gitProviderId")
+		.notNull()
+		.references(() => gitProvider.gitProviderId, { onDelete: "cascade" }),
+});
+
+export const bitbucketProviderRelations = relations(bitbucket, ({ one }) => ({
+	gitProvider: one(gitProvider, {
+		fields: [bitbucket.gitProviderId],
+		references: [gitProvider.gitProviderId],
+	}),
+}));
+
+const createSchema = createInsertSchema(bitbucket);
+
+export const apiCreateBitbucket = createSchema.extend({
+	bitbucketUsername: z.string().optional(),
+	appPassword: z.string().optional(),
+	bitbucketWorkspaceName: z.string().optional(),
+	gitProviderId: z.string().optional(),
+	authId: z.string().min(1),
+	name: z.string().min(1),
+});
+
+export const apiFindOneBitbucket = createSchema
+	.extend({
+		bitbucketId: z.string().min(1),
+	})
+	.pick({ bitbucketId: true });
+
+export const apiBitbucketTestConnection = createSchema
+	.extend({
+		bitbucketId: z.string().min(1),
+		bitbucketUsername: z.string().optional(),
+		workspaceName: z.string().optional(),
+	})
+	.pick({ bitbucketId: true, bitbucketUsername: true, workspaceName: true });
+
+export const apiFindBitbucketBranches = z.object({
+	owner: z.string(),
+	repo: z.string(),
+	bitbucketId: z.string().optional(),
+});
+
+export const apiUpdateBitbucket = createSchema.extend({
+	bitbucketId: z.string().min(1),
+	name: z.string().min(1),
+	bitbucketUsername: z.string().optional(),
+	bitbucketWorkspaceName: z.string().optional(),
+	adminId: z.string().optional(),
+});
--- a/packages/server/src/db/schema/certificate.ts
+++ b/packages/server/src/db/schema/certificate.ts
@@ -0,0 +1,43 @@
+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", {
+	certificateId: text("certificateId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	name: text("name").notNull(),
+	certificateData: text("certificateData").notNull(),
+	privateKey: text("privateKey").notNull(),
+	certificatePath: text("certificatePath")
+		.notNull()
+		.$defaultFn(() => generateAppName("certificate"))
+		.unique(),
+	autoRenew: boolean("autoRenew"),
+});
+
+export const apiCreateCertificate = createInsertSchema(certificates, {
+	name: z.string().min(1),
+	certificateData: z.string().min(1),
+	privateKey: z.string().min(1),
+	autoRenew: z.boolean().optional(),
+});
+
+export const apiFindCertificate = z.object({
+	certificateId: z.string().min(1),
+});
+
+export const apiUpdateCertificate = z.object({
+	certificateId: z.string().min(1),
+	name: z.string().min(1).optional(),
+	certificateData: z.string().min(1).optional(),
+	privateKey: z.string().min(1).optional(),
+	autoRenew: z.boolean().optional(),
+});
+
+export const apiDeleteCertificate = z.object({
+	certificateId: z.string().min(1),
+});
--- a/packages/server/src/db/schema/compose.ts
+++ b/packages/server/src/db/schema/compose.ts
@@ -0,0 +1,179 @@
+import { relations } from "drizzle-orm";
+import { boolean, integer, pgEnum, pgTable, text } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { bitbucket } from "./bitbucket";
+import { deployments } from "./deployment";
+import { domains } from "./domain";
+import { github } from "./github";
+import { gitlab } from "./gitlab";
+import { mounts } from "./mount";
+import { projects } from "./project";
+import { server } from "./server";
+import { applicationStatus } from "./shared";
+import { sshKeys } from "./ssh-key";
+import { generateAppName } from "./utils";
+
+export const sourceTypeCompose = pgEnum("sourceTypeCompose", [
+	"git",
+	"github",
+	"gitlab",
+	"bitbucket",
+	"raw",
+]);
+
+export const composeType = pgEnum("composeType", ["docker-compose", "stack"]);
+
+export const compose = pgTable("compose", {
+	composeId: text("composeId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	name: text("name").notNull(),
+	appName: text("appName")
+		.notNull()
+		.$defaultFn(() => generateAppName("compose")),
+	description: text("description"),
+	env: text("env"),
+	composeFile: text("composeFile").notNull().default(""),
+	refreshToken: text("refreshToken").$defaultFn(() => nanoid()),
+	sourceType: sourceTypeCompose("sourceType").notNull().default("github"),
+	composeType: composeType("composeType").notNull().default("docker-compose"),
+	// Github
+	repository: text("repository"),
+	owner: text("owner"),
+	branch: text("branch"),
+	autoDeploy: boolean("autoDeploy").$defaultFn(() => true),
+	// Gitlab
+	gitlabProjectId: integer("gitlabProjectId"),
+	gitlabRepository: text("gitlabRepository"),
+	gitlabOwner: text("gitlabOwner"),
+	gitlabBranch: text("gitlabBranch"),
+	gitlabPathNamespace: text("gitlabPathNamespace"),
+	// Bitbucket
+	bitbucketRepository: text("bitbucketRepository"),
+	bitbucketOwner: text("bitbucketOwner"),
+	bitbucketBranch: text("bitbucketBranch"),
+	// Git
+	customGitUrl: text("customGitUrl"),
+	customGitBranch: text("customGitBranch"),
+	customGitSSHKeyId: text("customGitSSHKeyId").references(
+		() => sshKeys.sshKeyId,
+		{
+			onDelete: "set null",
+		},
+	),
+	command: text("command").notNull().default(""),
+	//
+	composePath: text("composePath").notNull().default("./docker-compose.yml"),
+	suffix: text("suffix").notNull().default(""),
+	randomize: boolean("randomize").notNull().default(false),
+	composeStatus: applicationStatus("composeStatus").notNull().default("idle"),
+	projectId: text("projectId")
+		.notNull()
+		.references(() => projects.projectId, { onDelete: "cascade" }),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+
+	githubId: text("githubId").references(() => github.githubId, {
+		onDelete: "set null",
+	}),
+	gitlabId: text("gitlabId").references(() => gitlab.gitlabId, {
+		onDelete: "set null",
+	}),
+	bitbucketId: text("bitbucketId").references(() => bitbucket.bitbucketId, {
+		onDelete: "set null",
+	}),
+	serverId: text("serverId").references(() => server.serverId, {
+		onDelete: "cascade",
+	}),
+});
+
+export const composeRelations = relations(compose, ({ one, many }) => ({
+	project: one(projects, {
+		fields: [compose.projectId],
+		references: [projects.projectId],
+	}),
+	deployments: many(deployments),
+	mounts: many(mounts),
+	customGitSSHKey: one(sshKeys, {
+		fields: [compose.customGitSSHKeyId],
+		references: [sshKeys.sshKeyId],
+	}),
+	domains: many(domains),
+	github: one(github, {
+		fields: [compose.githubId],
+		references: [github.githubId],
+	}),
+	gitlab: one(gitlab, {
+		fields: [compose.gitlabId],
+		references: [gitlab.gitlabId],
+	}),
+	bitbucket: one(bitbucket, {
+		fields: [compose.bitbucketId],
+		references: [bitbucket.bitbucketId],
+	}),
+	server: one(server, {
+		fields: [compose.serverId],
+		references: [server.serverId],
+	}),
+}));
+
+const createSchema = createInsertSchema(compose, {
+	name: z.string().min(1),
+	description: z.string(),
+	env: z.string().optional(),
+	composeFile: z.string().min(1),
+	projectId: z.string(),
+	customGitSSHKeyId: z.string().optional(),
+	command: z.string().optional(),
+	composePath: z.string().min(1),
+	composeType: z.enum(["docker-compose", "stack"]).optional(),
+});
+
+export const apiCreateCompose = createSchema.pick({
+	name: true,
+	description: true,
+	projectId: true,
+	composeType: true,
+	appName: true,
+	serverId: true,
+});
+
+export const apiCreateComposeByTemplate = createSchema
+	.pick({
+		projectId: true,
+	})
+	.extend({
+		id: z.string().min(1),
+		serverId: z.string().optional(),
+	});
+
+export const apiFindCompose = z.object({
+	composeId: z.string().min(1),
+});
+
+export const apiFetchServices = z.object({
+	composeId: z.string().min(1),
+	type: z.enum(["fetch", "cache"]).optional().default("cache"),
+});
+
+export const apiUpdateCompose = createSchema
+	.partial()
+	.extend({
+		composeId: z.string(),
+		composeFile: z.string().optional(),
+		command: z.string().optional(),
+	})
+	.omit({ serverId: true });
+
+export const apiRandomizeCompose = createSchema
+	.pick({
+		composeId: true,
+	})
+	.extend({
+		suffix: z.string().optional(),
+		composeId: z.string().min(1),
+	});
--- a/packages/server/src/db/schema/deployment.ts
+++ b/packages/server/src/db/schema/deployment.ts
@@ -0,0 +1,125 @@
+import { relations } from "drizzle-orm";
+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";
+import { server } from "./server";
+
+export const deploymentStatus = pgEnum("deploymentStatus", [
+	"running",
+	"done",
+	"error",
+]);
+
+export const deployments = pgTable("deployment", {
+	deploymentId: text("deploymentId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	title: text("title").notNull(),
+	description: text("description"),
+	status: deploymentStatus("status").default("running"),
+	logPath: text("logPath").notNull(),
+	applicationId: text("applicationId").references(
+		() => applications.applicationId,
+		{ onDelete: "cascade" },
+	),
+	composeId: text("composeId").references(() => compose.composeId, {
+		onDelete: "cascade",
+	}),
+	serverId: text("serverId").references(() => server.serverId, {
+		onDelete: "cascade",
+	}),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+});
+
+export const deploymentsRelations = relations(deployments, ({ one }) => ({
+	application: one(applications, {
+		fields: [deployments.applicationId],
+		references: [applications.applicationId],
+	}),
+	compose: one(compose, {
+		fields: [deployments.composeId],
+		references: [compose.composeId],
+	}),
+	server: one(server, {
+		fields: [deployments.serverId],
+		references: [server.serverId],
+	}),
+}));
+
+const schema = createInsertSchema(deployments, {
+	title: z.string().min(1),
+	status: z.string().default("running"),
+	logPath: z.string().min(1),
+	applicationId: z.string(),
+	composeId: z.string(),
+	description: z.string().optional(),
+});
+
+export const apiCreateDeployment = schema
+	.pick({
+		title: true,
+		status: true,
+		logPath: true,
+		applicationId: true,
+		description: true,
+	})
+	.extend({
+		applicationId: z.string().min(1),
+	});
+
+export const apiCreateDeploymentCompose = schema
+	.pick({
+		title: true,
+		status: true,
+		logPath: true,
+		composeId: true,
+		description: true,
+	})
+	.extend({
+		composeId: z.string().min(1),
+	});
+
+export const apiCreateDeploymentServer = schema
+	.pick({
+		title: true,
+		status: true,
+		logPath: true,
+		serverId: true,
+		description: true,
+	})
+	.extend({
+		serverId: z.string().min(1),
+	});
+
+export const apiFindAllByApplication = schema
+	.pick({
+		applicationId: true,
+	})
+	.extend({
+		applicationId: z.string().min(1),
+	})
+	.required();
+
+export const apiFindAllByCompose = schema
+	.pick({
+		composeId: true,
+	})
+	.extend({
+		composeId: z.string().min(1),
+	})
+	.required();
+
+export const apiFindAllByServer = schema
+	.pick({
+		serverId: true,
+	})
+	.extend({
+		serverId: z.string().min(1),
+	})
+	.required();
--- a/packages/server/src/db/schema/destination.ts
+++ b/packages/server/src/db/schema/destination.ts
@@ -0,0 +1,80 @@
+import { relations } from "drizzle-orm";
+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";
+
+export const destinations = pgTable("destination", {
+	destinationId: text("destinationId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	name: text("name").notNull(),
+	accessKey: text("accessKey").notNull(),
+	secretAccessKey: text("secretAccessKey").notNull(),
+	bucket: text("bucket").notNull(),
+	region: text("region").notNull(),
+	//   maybe it can be null
+	endpoint: text("endpoint").notNull(),
+	adminId: text("adminId")
+		.notNull()
+		.references(() => admins.adminId, { onDelete: "cascade" }),
+});
+
+export const destinationsRelations = relations(
+	destinations,
+	({ many, one }) => ({
+		backups: many(backups),
+		admin: one(admins, {
+			fields: [destinations.adminId],
+			references: [admins.adminId],
+		}),
+	}),
+);
+
+const createSchema = createInsertSchema(destinations, {
+	destinationId: z.string(),
+	name: z.string().min(1),
+	accessKey: z.string(),
+	bucket: z.string(),
+	endpoint: z.string(),
+	secretAccessKey: z.string(),
+	region: z.string(),
+});
+
+export const apiCreateDestination = createSchema
+	.pick({
+		name: true,
+		accessKey: true,
+		bucket: true,
+		region: true,
+		endpoint: true,
+		secretAccessKey: true,
+	})
+	.required();
+
+export const apiFindOneDestination = createSchema
+	.pick({
+		destinationId: true,
+	})
+	.required();
+
+export const apiRemoveDestination = createSchema
+	.pick({
+		destinationId: true,
+	})
+	.required();
+
+export const apiUpdateDestination = createSchema
+	.pick({
+		name: true,
+		accessKey: true,
+		bucket: true,
+		region: true,
+		endpoint: true,
+		secretAccessKey: true,
+		destinationId: true,
+	})
+	.required();
--- a/packages/server/src/db/schema/domain.ts
+++ b/packages/server/src/db/schema/domain.ts
@@ -0,0 +1,98 @@
+import { relations } from "drizzle-orm";
+import {
+	boolean,
+	integer,
+	pgEnum,
+	pgTable,
+	serial,
+	text,
+} from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { domain } from "../validations/domain";
+import { applications } from "./application";
+import { compose } from "./compose";
+import { certificateType } from "./shared";
+
+export const domainType = pgEnum("domainType", ["compose", "application"]);
+
+export const domains = pgTable("domain", {
+	domainId: text("domainId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	host: text("host").notNull(),
+	https: boolean("https").notNull().default(false),
+	port: integer("port").default(3000),
+	path: text("path").default("/"),
+	serviceName: text("serviceName"),
+	domainType: domainType("domainType").default("application"),
+	uniqueConfigKey: serial("uniqueConfigKey"),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+	composeId: text("composeId").references(() => compose.composeId, {
+		onDelete: "cascade",
+	}),
+	applicationId: text("applicationId").references(
+		() => applications.applicationId,
+		{ onDelete: "cascade" },
+	),
+	certificateType: certificateType("certificateType").notNull().default("none"),
+});
+
+export const domainsRelations = relations(domains, ({ one }) => ({
+	application: one(applications, {
+		fields: [domains.applicationId],
+		references: [applications.applicationId],
+	}),
+	compose: one(compose, {
+		fields: [domains.composeId],
+		references: [compose.composeId],
+	}),
+}));
+
+const createSchema = createInsertSchema(domains, domain._def.schema.shape);
+
+export const apiCreateDomain = createSchema.pick({
+	host: true,
+	path: true,
+	port: true,
+	https: true,
+	applicationId: true,
+	certificateType: true,
+	composeId: true,
+	serviceName: true,
+	domainType: true,
+});
+
+export const apiFindDomain = createSchema
+	.pick({
+		domainId: true,
+	})
+	.required();
+
+export const apiFindDomainByApplication = createSchema.pick({
+	applicationId: true,
+});
+
+export const apiCreateTraefikMeDomain = createSchema.pick({}).extend({
+	appName: z.string().min(1),
+});
+
+export const apiFindDomainByCompose = createSchema.pick({
+	composeId: true,
+});
+
+export const apiUpdateDomain = createSchema
+	.pick({
+		host: true,
+		path: true,
+		port: true,
+		https: true,
+		certificateType: true,
+		serviceName: true,
+		domainType: true,
+	})
+	.merge(createSchema.pick({ domainId: true }).required());
--- a/packages/server/src/db/schema/git-provider.ts
+++ b/packages/server/src/db/schema/git-provider.ts
@@ -0,0 +1,57 @@
+import { relations } from "drizzle-orm";
+import { 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 { bitbucket } from "./bitbucket";
+import { github } from "./github";
+import { gitlab } from "./gitlab";
+
+export const gitProviderType = pgEnum("gitProviderType", [
+	"github",
+	"gitlab",
+	"bitbucket",
+]);
+
+export const gitProvider = pgTable("git_provider", {
+	gitProviderId: text("gitProviderId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	name: text("name").notNull(),
+	providerType: gitProviderType("providerType").notNull().default("github"),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+	adminId: text("adminId").references(() => admins.adminId, {
+		onDelete: "cascade",
+	}),
+});
+
+export const gitProviderRelations = relations(gitProvider, ({ one, many }) => ({
+	github: one(github, {
+		fields: [gitProvider.gitProviderId],
+		references: [github.gitProviderId],
+	}),
+	gitlab: one(gitlab, {
+		fields: [gitProvider.gitProviderId],
+		references: [gitlab.gitProviderId],
+	}),
+	bitbucket: one(bitbucket, {
+		fields: [gitProvider.gitProviderId],
+		references: [bitbucket.gitProviderId],
+	}),
+	admin: one(admins, {
+		fields: [gitProvider.adminId],
+		references: [admins.adminId],
+	}),
+}));
+
+const createSchema = createInsertSchema(gitProvider);
+
+export const apiRemoveGitProvider = createSchema
+	.extend({
+		gitProviderId: z.string().min(1),
+	})
+	.pick({ gitProviderId: true });
--- a/packages/server/src/db/schema/github.ts
+++ b/packages/server/src/db/schema/github.ts
@@ -0,0 +1,61 @@
+import { relations } from "drizzle-orm";
+import { integer, pgTable, text } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { gitProvider } from "./git-provider";
+
+export const github = pgTable("github", {
+	githubId: text("githubId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	githubAppName: text("githubAppName"),
+	githubAppId: integer("githubAppId"),
+	githubClientId: text("githubClientId"),
+	githubClientSecret: text("githubClientSecret"),
+	githubInstallationId: text("githubInstallationId"),
+	githubPrivateKey: text("githubPrivateKey"),
+	githubWebhookSecret: text("githubWebhookSecret"),
+	gitProviderId: text("gitProviderId")
+		.notNull()
+		.references(() => gitProvider.gitProviderId, { onDelete: "cascade" }),
+});
+
+export const githubProviderRelations = relations(github, ({ one }) => ({
+	gitProvider: one(gitProvider, {
+		fields: [github.gitProviderId],
+		references: [gitProvider.gitProviderId],
+	}),
+}));
+
+const createSchema = createInsertSchema(github);
+export const apiCreateGithub = createSchema.extend({
+	githubAppName: z.string().optional(),
+	githubAppId: z.number().optional(),
+	githubClientId: z.string().optional(),
+	githubClientSecret: z.string().optional(),
+	githubInstallationId: z.string().optional(),
+	githubPrivateKey: z.string().optional(),
+	githubWebhookSecret: z.string().nullable(),
+	gitProviderId: z.string().optional(),
+	name: z.string().min(1),
+});
+
+export const apiFindGithubBranches = z.object({
+	repo: z.string().min(1),
+	owner: z.string().min(1),
+	githubId: z.string().optional(),
+});
+
+export const apiFindOneGithub = createSchema
+	.extend({
+		githubId: z.string().min(1),
+	})
+	.pick({ githubId: true });
+
+export const apiUpdateGithub = createSchema.extend({
+	githubId: z.string().min(1),
+	name: z.string().min(1),
+	gitProviderId: z.string().min(1),
+});
--- a/packages/server/src/db/schema/gitlab.ts
+++ b/packages/server/src/db/schema/gitlab.ts
@@ -0,0 +1,70 @@
+import { relations } from "drizzle-orm";
+import { integer, pgTable, text } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { gitProvider } from "./git-provider";
+
+export const gitlab = pgTable("gitlab", {
+	gitlabId: text("gitlabId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	applicationId: text("application_id"),
+	redirectUri: text("redirect_uri"),
+	secret: text("secret"),
+	accessToken: text("access_token"),
+	refreshToken: text("refresh_token"),
+	groupName: text("group_name"),
+	expiresAt: integer("expires_at"),
+	gitProviderId: text("gitProviderId")
+		.notNull()
+		.references(() => gitProvider.gitProviderId, { onDelete: "cascade" }),
+});
+
+export const gitlabProviderRelations = relations(gitlab, ({ one }) => ({
+	gitProvider: one(gitProvider, {
+		fields: [gitlab.gitProviderId],
+		references: [gitProvider.gitProviderId],
+	}),
+}));
+
+const createSchema = createInsertSchema(gitlab);
+
+export const apiCreateGitlab = createSchema.extend({
+	applicationId: z.string().optional(),
+	secret: z.string().optional(),
+	groupName: z.string().optional(),
+	gitProviderId: z.string().optional(),
+	redirectUri: z.string().optional(),
+	authId: z.string().min(1),
+	name: z.string().min(1),
+});
+
+export const apiFindOneGitlab = createSchema
+	.extend({
+		gitlabId: z.string().min(1),
+	})
+	.pick({ gitlabId: true });
+
+export const apiGitlabTestConnection = createSchema
+	.extend({
+		groupName: z.string().optional(),
+	})
+	.pick({ gitlabId: true, groupName: true });
+
+export const apiFindGitlabBranches = z.object({
+	id: z.number().optional(),
+	owner: z.string(),
+	repo: z.string(),
+	gitlabId: z.string().optional(),
+});
+
+export const apiUpdateGitlab = createSchema.extend({
+	applicationId: z.string().optional(),
+	secret: z.string().optional(),
+	groupName: z.string().optional(),
+	redirectUri: z.string().optional(),
+	name: z.string().min(1),
+	gitlabId: z.string().min(1),
+});
--- a/packages/server/src/db/schema/index.ts
+++ b/packages/server/src/db/schema/index.ts
@@ -0,0 +1,31 @@
+export * from "./application";
+export * from "./postgres";
+export * from "./user";
+export * from "./admin";
+export * from "./auth";
+export * from "./project";
+export * from "./domain";
+export * from "./mariadb";
+export * from "./mongo";
+export * from "./mysql";
+export * from "./backups";
+export * from "./destination";
+export * from "./deployment";
+export * from "./mount";
+export * from "./certificate";
+export * from "./session";
+export * from "./redirects";
+export * from "./security";
+export * from "./port";
+export * from "./redis";
+export * from "./shared";
+export * from "./compose";
+export * from "./registry";
+export * from "./notification";
+export * from "./ssh-key";
+export * from "./git-provider";
+export * from "./bitbucket";
+export * from "./github";
+export * from "./gitlab";
+export * from "./server";
+export * from "./utils";
--- a/packages/server/src/db/schema/mariadb.ts
+++ b/packages/server/src/db/schema/mariadb.ts
@@ -0,0 +1,148 @@
+import { relations } from "drizzle-orm";
+import { integer, pgTable, text } from "drizzle-orm/pg-core";
+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 { server } from "./server";
+import { applicationStatus } from "./shared";
+import { generateAppName } from "./utils";
+
+export const mariadb = pgTable("mariadb", {
+	mariadbId: text("mariadbId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	name: text("name").notNull(),
+	appName: text("appName")
+		.notNull()
+		.$defaultFn(() => generateAppName("mariadb"))
+		.unique(),
+	description: text("description"),
+	databaseName: text("databaseName").notNull(),
+	databaseUser: text("databaseUser").notNull(),
+	databasePassword: text("databasePassword").notNull(),
+	databaseRootPassword: text("rootPassword").notNull(),
+	dockerImage: text("dockerImage").notNull(),
+	command: text("command"),
+	env: text("env"),
+	// RESOURCES
+	memoryReservation: integer("memoryReservation"),
+	memoryLimit: integer("memoryLimit"),
+	cpuReservation: integer("cpuReservation"),
+	cpuLimit: integer("cpuLimit"),
+	//
+	externalPort: integer("externalPort"),
+	applicationStatus: applicationStatus("applicationStatus")
+		.notNull()
+		.default("idle"),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+	projectId: text("projectId")
+		.notNull()
+		.references(() => projects.projectId, { onDelete: "cascade" }),
+	serverId: text("serverId").references(() => server.serverId, {
+		onDelete: "cascade",
+	}),
+});
+
+export const mariadbRelations = relations(mariadb, ({ one, many }) => ({
+	project: one(projects, {
+		fields: [mariadb.projectId],
+		references: [projects.projectId],
+	}),
+	backups: many(backups),
+	mounts: many(mounts),
+	server: one(server, {
+		fields: [mariadb.serverId],
+		references: [server.serverId],
+	}),
+}));
+
+const createSchema = createInsertSchema(mariadb, {
+	mariadbId: z.string(),
+	name: z.string().min(1),
+	appName: z.string().min(1),
+	createdAt: z.string(),
+	databaseName: z.string().min(1),
+	databaseUser: z.string().min(1),
+	databasePassword: z.string(),
+	databaseRootPassword: z.string().optional(),
+	dockerImage: z.string().default("mariadb:6"),
+	command: z.string().optional(),
+	env: z.string().optional(),
+	memoryReservation: z.number().optional(),
+	memoryLimit: z.number().optional(),
+	cpuReservation: z.number().optional(),
+	cpuLimit: z.number().optional(),
+	projectId: z.string(),
+	applicationStatus: z.enum(["idle", "running", "done", "error"]),
+	externalPort: z.number(),
+	description: z.string().optional(),
+	serverId: z.string().optional(),
+});
+
+export const apiCreateMariaDB = createSchema
+	.pick({
+		name: true,
+		appName: true,
+		dockerImage: true,
+		databaseRootPassword: true,
+		projectId: true,
+		description: true,
+		databaseName: true,
+		databaseUser: true,
+		databasePassword: true,
+		serverId: true,
+	})
+	.required();
+
+export const apiFindOneMariaDB = createSchema
+	.pick({
+		mariadbId: true,
+	})
+	.required();
+
+export const apiChangeMariaDBStatus = createSchema
+	.pick({
+		mariadbId: true,
+		applicationStatus: true,
+	})
+	.required();
+
+export const apiSaveEnvironmentVariablesMariaDB = createSchema
+	.pick({
+		mariadbId: true,
+		env: true,
+	})
+	.required();
+
+export const apiSaveExternalPortMariaDB = createSchema
+	.pick({
+		mariadbId: true,
+		externalPort: true,
+	})
+	.required();
+
+export const apiDeployMariaDB = createSchema
+	.pick({
+		mariadbId: true,
+	})
+	.required();
+
+export const apiResetMariadb = createSchema
+	.pick({
+		mariadbId: true,
+		appName: true,
+	})
+	.required();
+
+export const apiUpdateMariaDB = createSchema
+	.partial()
+	.extend({
+		mariadbId: z.string().min(1),
+	})
+	.omit({ serverId: true });
--- a/packages/server/src/db/schema/mongo.ts
+++ b/packages/server/src/db/schema/mongo.ts
@@ -0,0 +1,140 @@
+import { relations } from "drizzle-orm";
+import { integer, pgTable, text } from "drizzle-orm/pg-core";
+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 { server } from "./server";
+import { applicationStatus } from "./shared";
+import { generateAppName } from "./utils";
+
+export const mongo = pgTable("mongo", {
+	mongoId: text("mongoId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	name: text("name").notNull(),
+	appName: text("appName")
+		.notNull()
+		.$defaultFn(() => generateAppName("mongo"))
+		.unique(),
+	description: text("description"),
+	databaseUser: text("databaseUser").notNull(),
+	databasePassword: text("databasePassword").notNull(),
+	dockerImage: text("dockerImage").notNull(),
+	command: text("command"),
+	env: text("env"),
+	memoryReservation: integer("memoryReservation"),
+	memoryLimit: integer("memoryLimit"),
+	cpuReservation: integer("cpuReservation"),
+	cpuLimit: integer("cpuLimit"),
+	externalPort: integer("externalPort"),
+	applicationStatus: applicationStatus("applicationStatus")
+		.notNull()
+		.default("idle"),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+	projectId: text("projectId")
+		.notNull()
+		.references(() => projects.projectId, { onDelete: "cascade" }),
+	serverId: text("serverId").references(() => server.serverId, {
+		onDelete: "cascade",
+	}),
+});
+
+export const mongoRelations = relations(mongo, ({ one, many }) => ({
+	project: one(projects, {
+		fields: [mongo.projectId],
+		references: [projects.projectId],
+	}),
+	backups: many(backups),
+	mounts: many(mounts),
+	server: one(server, {
+		fields: [mongo.serverId],
+		references: [server.serverId],
+	}),
+}));
+
+const createSchema = createInsertSchema(mongo, {
+	appName: z.string().min(1),
+	createdAt: z.string(),
+	mongoId: z.string(),
+	name: z.string().min(1),
+	databasePassword: z.string(),
+	databaseUser: z.string().min(1),
+	dockerImage: z.string().default("mongo:15"),
+	command: z.string().optional(),
+	env: z.string().optional(),
+	memoryReservation: z.number().optional(),
+	memoryLimit: z.number().optional(),
+	cpuReservation: z.number().optional(),
+	cpuLimit: z.number().optional(),
+	projectId: z.string(),
+	applicationStatus: z.enum(["idle", "running", "done", "error"]),
+	externalPort: z.number(),
+	description: z.string().optional(),
+	serverId: z.string().optional(),
+});
+
+export const apiCreateMongo = createSchema
+	.pick({
+		name: true,
+		appName: true,
+		dockerImage: true,
+		projectId: true,
+		description: true,
+		databaseUser: true,
+		databasePassword: true,
+		serverId: true,
+	})
+	.required();
+
+export const apiFindOneMongo = createSchema
+	.pick({
+		mongoId: true,
+	})
+	.required();
+
+export const apiChangeMongoStatus = createSchema
+	.pick({
+		mongoId: true,
+		applicationStatus: true,
+	})
+	.required();
+
+export const apiSaveEnvironmentVariablesMongo = createSchema
+	.pick({
+		mongoId: true,
+		env: true,
+	})
+	.required();
+
+export const apiSaveExternalPortMongo = createSchema
+	.pick({
+		mongoId: true,
+		externalPort: true,
+	})
+	.required();
+
+export const apiDeployMongo = createSchema
+	.pick({
+		mongoId: true,
+	})
+	.required();
+
+export const apiUpdateMongo = createSchema
+	.partial()
+	.extend({
+		mongoId: z.string().min(1),
+	})
+	.omit({ serverId: true });
+
+export const apiResetMongo = createSchema
+	.pick({
+		mongoId: true,
+		appName: true,
+	})
+	.required();
--- a/packages/server/src/db/schema/mount.ts
+++ b/packages/server/src/db/schema/mount.ts
@@ -0,0 +1,160 @@
+import { relations } from "drizzle-orm";
+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";
+import { mariadb } from "./mariadb";
+import { mongo } from "./mongo";
+import { mysql } from "./mysql";
+import { postgres } from "./postgres";
+import { redis } from "./redis";
+
+export const serviceType = pgEnum("serviceType", [
+	"application",
+	"postgres",
+	"mysql",
+	"mariadb",
+	"mongo",
+	"redis",
+	"compose",
+]);
+
+export const mountType = pgEnum("mountType", ["bind", "volume", "file"]);
+
+export const mounts = pgTable("mount", {
+	mountId: text("mountId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	type: mountType("type").notNull(),
+	hostPath: text("hostPath"),
+	volumeName: text("volumeName"),
+	filePath: text("filePath"),
+	content: text("content"),
+	serviceType: serviceType("serviceType").notNull().default("application"),
+	mountPath: text("mountPath").notNull(),
+	applicationId: text("applicationId").references(
+		() => applications.applicationId,
+		{ onDelete: "cascade" },
+	),
+	postgresId: text("postgresId").references(() => postgres.postgresId, {
+		onDelete: "cascade",
+	}),
+	mariadbId: text("mariadbId").references(() => mariadb.mariadbId, {
+		onDelete: "cascade",
+	}),
+	mongoId: text("mongoId").references(() => mongo.mongoId, {
+		onDelete: "cascade",
+	}),
+	mysqlId: text("mysqlId").references(() => mysql.mysqlId, {
+		onDelete: "cascade",
+	}),
+	redisId: text("redisId").references(() => redis.redisId, {
+		onDelete: "cascade",
+	}),
+	composeId: text("composeId").references(() => compose.composeId, {
+		onDelete: "cascade",
+	}),
+});
+
+export const MountssRelations = relations(mounts, ({ one }) => ({
+	application: one(applications, {
+		fields: [mounts.applicationId],
+		references: [applications.applicationId],
+	}),
+	postgres: one(postgres, {
+		fields: [mounts.postgresId],
+		references: [postgres.postgresId],
+	}),
+	mariadb: one(mariadb, {
+		fields: [mounts.mariadbId],
+		references: [mariadb.mariadbId],
+	}),
+	mongo: one(mongo, {
+		fields: [mounts.mongoId],
+		references: [mongo.mongoId],
+	}),
+	mysql: one(mysql, {
+		fields: [mounts.mysqlId],
+		references: [mysql.mysqlId],
+	}),
+	redis: one(redis, {
+		fields: [mounts.redisId],
+		references: [redis.redisId],
+	}),
+	compose: one(compose, {
+		fields: [mounts.composeId],
+		references: [compose.composeId],
+	}),
+}));
+
+const createSchema = createInsertSchema(mounts, {
+	applicationId: z.string(),
+	type: z.enum(["bind", "volume", "file"]),
+	hostPath: z.string().optional(),
+	volumeName: z.string().optional(),
+	content: z.string().optional(),
+	mountPath: z.string().min(1),
+	mountId: z.string().optional(),
+	filePath: z.string().optional(),
+	serviceType: z
+		.enum([
+			"application",
+			"postgres",
+			"mysql",
+			"mariadb",
+			"mongo",
+			"redis",
+			"compose",
+		])
+		.default("application"),
+});
+
+export type ServiceType = NonNullable<
+	z.infer<typeof createSchema>["serviceType"]
+>;
+
+export const apiCreateMount = createSchema
+	.pick({
+		type: true,
+		hostPath: true,
+		volumeName: true,
+		content: true,
+		mountPath: true,
+		serviceType: true,
+		filePath: true,
+	})
+	.extend({
+		serviceId: z.string().min(1),
+	});
+
+export const apiFindOneMount = createSchema
+	.pick({
+		mountId: true,
+	})
+	.required();
+
+export const apiRemoveMount = createSchema
+	.pick({
+		mountId: true,
+	})
+	// .extend({
+	// 	appName: z.string().min(1),
+	// })
+	.required();
+
+export const apiFindMountByApplicationId = createSchema
+	.extend({
+		serviceId: z.string().min(1),
+	})
+	.pick({
+		serviceId: true,
+		serviceType: true,
+	})
+	.required();
+
+export const apiUpdateMount = createSchema.partial().extend({
+	mountId: z.string().min(1),
+});
--- a/packages/server/src/db/schema/mysql.ts
+++ b/packages/server/src/db/schema/mysql.ts
@@ -0,0 +1,146 @@
+import { relations } from "drizzle-orm";
+import { integer, pgTable, text } from "drizzle-orm/pg-core";
+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 { server } from "./server";
+import { applicationStatus } from "./shared";
+import { generateAppName } from "./utils";
+
+export const mysql = pgTable("mysql", {
+	mysqlId: text("mysqlId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	name: text("name").notNull(),
+	appName: text("appName")
+		.notNull()
+		.$defaultFn(() => generateAppName("mysql"))
+		.unique(),
+	description: text("description"),
+	databaseName: text("databaseName").notNull(),
+	databaseUser: text("databaseUser").notNull(),
+	databasePassword: text("databasePassword").notNull(),
+	databaseRootPassword: text("rootPassword").notNull(),
+	dockerImage: text("dockerImage").notNull(),
+	command: text("command"),
+	env: text("env"),
+	memoryReservation: integer("memoryReservation"),
+	memoryLimit: integer("memoryLimit"),
+	cpuReservation: integer("cpuReservation"),
+	cpuLimit: integer("cpuLimit"),
+	externalPort: integer("externalPort"),
+	applicationStatus: applicationStatus("applicationStatus")
+		.notNull()
+		.default("idle"),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+	projectId: text("projectId")
+		.notNull()
+		.references(() => projects.projectId, { onDelete: "cascade" }),
+	serverId: text("serverId").references(() => server.serverId, {
+		onDelete: "cascade",
+	}),
+});
+
+export const mysqlRelations = relations(mysql, ({ one, many }) => ({
+	project: one(projects, {
+		fields: [mysql.projectId],
+		references: [projects.projectId],
+	}),
+	backups: many(backups),
+	mounts: many(mounts),
+	server: one(server, {
+		fields: [mysql.serverId],
+		references: [server.serverId],
+	}),
+}));
+
+const createSchema = createInsertSchema(mysql, {
+	mysqlId: z.string(),
+	appName: z.string().min(1),
+	createdAt: z.string(),
+	name: z.string().min(1),
+	databaseName: z.string().min(1),
+	databaseUser: z.string().min(1),
+	databasePassword: z.string(),
+	databaseRootPassword: z.string().optional(),
+	dockerImage: z.string().default("mysql:8"),
+	command: z.string().optional(),
+	env: z.string().optional(),
+	memoryReservation: z.number().optional(),
+	memoryLimit: z.number().optional(),
+	cpuReservation: z.number().optional(),
+	cpuLimit: z.number().optional(),
+	projectId: z.string(),
+	applicationStatus: z.enum(["idle", "running", "done", "error"]),
+	externalPort: z.number(),
+	description: z.string().optional(),
+	serverId: z.string().optional(),
+});
+
+export const apiCreateMySql = createSchema
+	.pick({
+		name: true,
+		appName: true,
+		dockerImage: true,
+		projectId: true,
+		description: true,
+		databaseName: true,
+		databaseUser: true,
+		databasePassword: true,
+		databaseRootPassword: true,
+		serverId: true,
+	})
+	.required();
+
+export const apiFindOneMySql = createSchema
+	.pick({
+		mysqlId: true,
+	})
+	.required();
+
+export const apiChangeMySqlStatus = createSchema
+	.pick({
+		mysqlId: true,
+		applicationStatus: true,
+	})
+	.required();
+
+export const apiSaveEnvironmentVariablesMySql = createSchema
+	.pick({
+		mysqlId: true,
+		env: true,
+	})
+	.required();
+
+export const apiSaveExternalPortMySql = createSchema
+	.pick({
+		mysqlId: true,
+		externalPort: true,
+	})
+	.required();
+
+export const apiResetMysql = createSchema
+	.pick({
+		mysqlId: true,
+		appName: true,
+	})
+	.required();
+
+export const apiDeployMySql = createSchema
+	.pick({
+		mysqlId: true,
+	})
+	.required();
+
+export const apiUpdateMySql = createSchema
+	.partial()
+	.extend({
+		mysqlId: z.string().min(1),
+	})
+	.omit({ serverId: true });
--- a/packages/server/src/db/schema/notification.ts
+++ b/packages/server/src/db/schema/notification.ts
@@ -0,0 +1,240 @@
+import { relations } from "drizzle-orm";
+import { boolean, integer, 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";
+
+export const notificationType = pgEnum("notificationType", [
+	"slack",
+	"telegram",
+	"discord",
+	"email",
+]);
+
+export const notifications = pgTable("notification", {
+	notificationId: text("notificationId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	name: text("name").notNull(),
+	appDeploy: boolean("appDeploy").notNull().default(false),
+	appBuildError: boolean("appBuildError").notNull().default(false),
+	databaseBackup: boolean("databaseBackup").notNull().default(false),
+	dokployRestart: boolean("dokployRestart").notNull().default(false),
+	dockerCleanup: boolean("dockerCleanup").notNull().default(false),
+	notificationType: notificationType("notificationType").notNull(),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+	slackId: text("slackId").references(() => slack.slackId, {
+		onDelete: "cascade",
+	}),
+	telegramId: text("telegramId").references(() => telegram.telegramId, {
+		onDelete: "cascade",
+	}),
+	discordId: text("discordId").references(() => discord.discordId, {
+		onDelete: "cascade",
+	}),
+	emailId: text("emailId").references(() => email.emailId, {
+		onDelete: "cascade",
+	}),
+	adminId: text("adminId").references(() => admins.adminId, {
+		onDelete: "cascade",
+	}),
+});
+
+export const slack = pgTable("slack", {
+	slackId: text("slackId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	webhookUrl: text("webhookUrl").notNull(),
+	channel: text("channel"),
+});
+
+export const telegram = pgTable("telegram", {
+	telegramId: text("telegramId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	botToken: text("botToken").notNull(),
+	chatId: text("chatId").notNull(),
+});
+
+export const discord = pgTable("discord", {
+	discordId: text("discordId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	webhookUrl: text("webhookUrl").notNull(),
+});
+
+export const email = pgTable("email", {
+	emailId: text("emailId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	smtpServer: text("smtpServer").notNull(),
+	smtpPort: integer("smtpPort").notNull(),
+	username: text("username").notNull(),
+	password: text("password").notNull(),
+	fromAddress: text("fromAddress").notNull(),
+	toAddresses: text("toAddress").array().notNull(),
+});
+
+export const notificationsRelations = relations(notifications, ({ one }) => ({
+	slack: one(slack, {
+		fields: [notifications.slackId],
+		references: [slack.slackId],
+	}),
+	telegram: one(telegram, {
+		fields: [notifications.telegramId],
+		references: [telegram.telegramId],
+	}),
+	discord: one(discord, {
+		fields: [notifications.discordId],
+		references: [discord.discordId],
+	}),
+	email: one(email, {
+		fields: [notifications.emailId],
+		references: [email.emailId],
+	}),
+	admin: one(admins, {
+		fields: [notifications.adminId],
+		references: [admins.adminId],
+	}),
+}));
+
+export const notificationsSchema = createInsertSchema(notifications);
+
+export const apiCreateSlack = notificationsSchema
+	.pick({
+		appBuildError: true,
+		databaseBackup: true,
+		dokployRestart: true,
+		name: true,
+		appDeploy: true,
+		dockerCleanup: true,
+	})
+	.extend({
+		webhookUrl: z.string().min(1),
+		channel: z.string(),
+	})
+	.required();
+
+export const apiUpdateSlack = apiCreateSlack.partial().extend({
+	notificationId: z.string().min(1),
+	slackId: z.string(),
+	adminId: z.string().optional(),
+});
+
+export const apiTestSlackConnection = apiCreateSlack.pick({
+	webhookUrl: true,
+	channel: true,
+});
+
+export const apiCreateTelegram = notificationsSchema
+	.pick({
+		appBuildError: true,
+		databaseBackup: true,
+		dokployRestart: true,
+		name: true,
+		appDeploy: true,
+		dockerCleanup: true,
+	})
+	.extend({
+		botToken: z.string().min(1),
+		chatId: z.string().min(1),
+	})
+	.required();
+
+export const apiUpdateTelegram = apiCreateTelegram.partial().extend({
+	notificationId: z.string().min(1),
+	telegramId: z.string().min(1),
+	adminId: z.string().optional(),
+});
+
+export const apiTestTelegramConnection = apiCreateTelegram.pick({
+	botToken: true,
+	chatId: true,
+});
+
+export const apiCreateDiscord = notificationsSchema
+	.pick({
+		appBuildError: true,
+		databaseBackup: true,
+		dokployRestart: true,
+		name: true,
+		appDeploy: true,
+		dockerCleanup: true,
+	})
+	.extend({
+		webhookUrl: z.string().min(1),
+	})
+	.required();
+
+export const apiUpdateDiscord = apiCreateDiscord.partial().extend({
+	notificationId: z.string().min(1),
+	discordId: z.string().min(1),
+	adminId: z.string().optional(),
+});
+
+export const apiTestDiscordConnection = apiCreateDiscord.pick({
+	webhookUrl: true,
+});
+
+export const apiCreateEmail = notificationsSchema
+	.pick({
+		appBuildError: true,
+		databaseBackup: true,
+		dokployRestart: true,
+		name: true,
+		appDeploy: true,
+		dockerCleanup: true,
+	})
+	.extend({
+		smtpServer: z.string().min(1),
+		smtpPort: z.number().min(1),
+		username: z.string().min(1),
+		password: z.string().min(1),
+		fromAddress: z.string().min(1),
+		toAddresses: z.array(z.string()).min(1),
+	})
+	.required();
+
+export const apiUpdateEmail = apiCreateEmail.partial().extend({
+	notificationId: z.string().min(1),
+	emailId: z.string().min(1),
+	adminId: z.string().optional(),
+});
+
+export const apiTestEmailConnection = apiCreateEmail.pick({
+	smtpServer: true,
+	smtpPort: true,
+	username: true,
+	password: true,
+	toAddresses: true,
+	fromAddress: true,
+});
+
+export const apiFindOneNotification = notificationsSchema
+	.pick({
+		notificationId: true,
+	})
+	.required();
+
+export const apiSendTest = notificationsSchema
+	.extend({
+		botToken: z.string(),
+		chatId: z.string(),
+		webhookUrl: z.string(),
+		channel: z.string(),
+		smtpServer: z.string(),
+		smtpPort: z.number(),
+		fromAddress: z.string(),
+		username: z.string(),
+		password: z.string(),
+		toAddresses: z.array(z.string()),
+	})
+	.partial();
--- a/packages/server/src/db/schema/port.ts
+++ b/packages/server/src/db/schema/port.ts
@@ -0,0 +1,61 @@
+import { relations } from "drizzle-orm";
+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"]);
+
+export const ports = pgTable("port", {
+	portId: text("portId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	publishedPort: integer("publishedPort").notNull(),
+	targetPort: integer("targetPort").notNull(),
+	protocol: protocolType("protocol").notNull(),
+
+	applicationId: text("applicationId")
+		.notNull()
+		.references(() => applications.applicationId, { onDelete: "cascade" }),
+});
+
+export const portsRelations = relations(ports, ({ one }) => ({
+	application: one(applications, {
+		fields: [ports.applicationId],
+		references: [applications.applicationId],
+	}),
+}));
+
+const createSchema = createInsertSchema(ports, {
+	portId: z.string().min(1),
+	applicationId: z.string().min(1),
+	publishedPort: z.number(),
+	targetPort: z.number(),
+	protocol: z.enum(["tcp", "udp"]).default("tcp"),
+});
+
+export const apiCreatePort = createSchema
+	.pick({
+		publishedPort: true,
+		targetPort: true,
+		protocol: true,
+		applicationId: true,
+	})
+	.required();
+
+export const apiFindOnePort = createSchema
+	.pick({
+		portId: true,
+	})
+	.required();
+
+export const apiUpdatePort = createSchema
+	.pick({
+		portId: true,
+		publishedPort: true,
+		targetPort: true,
+		protocol: true,
+	})
+	.required();
--- a/packages/server/src/db/schema/postgres.ts
+++ b/packages/server/src/db/schema/postgres.ts
@@ -0,0 +1,142 @@
+import { relations } from "drizzle-orm";
+import { integer, pgTable, text } from "drizzle-orm/pg-core";
+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 { server } from "./server";
+import { applicationStatus } from "./shared";
+import { generateAppName } from "./utils";
+
+export const postgres = pgTable("postgres", {
+	postgresId: text("postgresId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	name: text("name").notNull(),
+	appName: text("appName")
+		.notNull()
+		.$defaultFn(() => generateAppName("postgres"))
+		.unique(),
+	databaseName: text("databaseName").notNull(),
+	databaseUser: text("databaseUser").notNull(),
+	databasePassword: text("databasePassword").notNull(),
+	description: text("description"),
+	dockerImage: text("dockerImage").notNull(),
+	command: text("command"),
+	env: text("env"),
+	memoryReservation: integer("memoryReservation"),
+	externalPort: integer("externalPort"),
+	memoryLimit: integer("memoryLimit"),
+	cpuReservation: integer("cpuReservation"),
+	cpuLimit: integer("cpuLimit"),
+	applicationStatus: applicationStatus("applicationStatus")
+		.notNull()
+		.default("idle"),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+	projectId: text("projectId")
+		.notNull()
+		.references(() => projects.projectId, { onDelete: "cascade" }),
+	serverId: text("serverId").references(() => server.serverId, {
+		onDelete: "cascade",
+	}),
+});
+
+export const postgresRelations = relations(postgres, ({ one, many }) => ({
+	project: one(projects, {
+		fields: [postgres.projectId],
+		references: [projects.projectId],
+	}),
+	backups: many(backups),
+	mounts: many(mounts),
+	server: one(server, {
+		fields: [postgres.serverId],
+		references: [server.serverId],
+	}),
+}));
+
+const createSchema = createInsertSchema(postgres, {
+	postgresId: z.string(),
+	name: z.string().min(1),
+	databasePassword: z.string(),
+	databaseName: z.string().min(1),
+	databaseUser: z.string().min(1),
+	dockerImage: z.string().default("postgres:15"),
+	command: z.string().optional(),
+	env: z.string().optional(),
+	memoryReservation: z.number().optional(),
+	memoryLimit: z.number().optional(),
+	cpuReservation: z.number().optional(),
+	cpuLimit: z.number().optional(),
+	projectId: z.string(),
+	applicationStatus: z.enum(["idle", "running", "done", "error"]),
+	externalPort: z.number(),
+	createdAt: z.string(),
+	description: z.string().optional(),
+	serverId: z.string().optional(),
+});
+
+export const apiCreatePostgres = createSchema
+	.pick({
+		name: true,
+		appName: true,
+		databaseName: true,
+		databaseUser: true,
+		databasePassword: true,
+		dockerImage: true,
+		projectId: true,
+		description: true,
+		serverId: true,
+	})
+	.required();
+
+export const apiFindOnePostgres = createSchema
+	.pick({
+		postgresId: true,
+	})
+	.required();
+
+export const apiChangePostgresStatus = createSchema
+	.pick({
+		postgresId: true,
+		applicationStatus: true,
+	})
+	.required();
+
+export const apiSaveEnvironmentVariablesPostgres = createSchema
+	.pick({
+		postgresId: true,
+		env: true,
+	})
+	.required();
+
+export const apiSaveExternalPortPostgres = createSchema
+	.pick({
+		postgresId: true,
+		externalPort: true,
+	})
+	.required();
+
+export const apiDeployPostgres = createSchema
+	.pick({
+		postgresId: true,
+	})
+	.required();
+
+export const apiResetPostgres = createSchema
+	.pick({
+		postgresId: true,
+		appName: true,
+	})
+	.required();
+
+export const apiUpdatePostgres = createSchema
+	.partial()
+	.extend({
+		postgresId: z.string().min(1),
+	})
+	.omit({ serverId: true });
--- a/packages/server/src/db/schema/project.ts
+++ b/packages/server/src/db/schema/project.ts
@@ -0,0 +1,74 @@
+import { relations } from "drizzle-orm";
+
+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 { redis } from "./redis";
+
+export const projects = pgTable("project", {
+	projectId: text("projectId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	name: text("name").notNull(),
+	description: text("description"),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+	adminId: text("adminId")
+		.notNull()
+		.references(() => admins.adminId, { onDelete: "cascade" }),
+});
+
+export const projectRelations = relations(projects, ({ many, one }) => ({
+	mysql: many(mysql),
+	postgres: many(postgres),
+	mariadb: many(mariadb),
+	applications: many(applications),
+	mongo: many(mongo),
+	redis: many(redis),
+	compose: many(compose),
+	admin: one(admins, {
+		fields: [projects.adminId],
+		references: [admins.adminId],
+	}),
+}));
+
+const createSchema = createInsertSchema(projects, {
+	projectId: z.string().min(1),
+	name: z.string().min(1),
+	description: z.string().optional(),
+});
+
+export const apiCreateProject = createSchema.pick({
+	name: true,
+	description: true,
+});
+
+export const apiFindOneProject = createSchema
+	.pick({
+		projectId: true,
+	})
+	.required();
+
+export const apiRemoveProject = createSchema
+	.pick({
+		projectId: true,
+	})
+	.required();
+
+export const apiUpdateProject = createSchema
+	.pick({
+		name: true,
+		description: true,
+		projectId: true,
+	})
+	.required();
--- a/packages/server/src/db/schema/redirects.ts
+++ b/packages/server/src/db/schema/redirects.ts
@@ -0,0 +1,60 @@
+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 { applications } from "./application";
+
+export const redirects = pgTable("redirect", {
+	redirectId: text("redirectId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	regex: text("regex").notNull(),
+	replacement: text("replacement").notNull(),
+	permanent: boolean("permanent").notNull().default(false),
+	uniqueConfigKey: serial("uniqueConfigKey"),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+	applicationId: text("applicationId")
+		.notNull()
+		.references(() => applications.applicationId, { onDelete: "cascade" }),
+});
+
+export const redirectRelations = relations(redirects, ({ one }) => ({
+	application: one(applications, {
+		fields: [redirects.applicationId],
+		references: [applications.applicationId],
+	}),
+}));
+const createSchema = createInsertSchema(redirects, {
+	redirectId: z.string().min(1),
+	regex: z.string().min(1),
+	replacement: z.string().min(1),
+	permanent: z.boolean().optional(),
+});
+
+export const apiFindOneRedirect = createSchema
+	.pick({
+		redirectId: true,
+	})
+	.required();
+
+export const apiCreateRedirect = createSchema
+	.pick({
+		regex: true,
+		replacement: true,
+		permanent: true,
+		applicationId: true,
+	})
+	.required();
+
+export const apiUpdateRedirect = createSchema
+	.pick({
+		redirectId: true,
+		regex: true,
+		replacement: true,
+		permanent: true,
+	})
+	.required();
--- a/packages/server/src/db/schema/redis.ts
+++ b/packages/server/src/db/schema/redis.ts
@@ -0,0 +1,135 @@
+import { relations } from "drizzle-orm";
+import { integer, pgTable, text } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { mounts } from "./mount";
+import { projects } from "./project";
+import { server } from "./server";
+import { applicationStatus } from "./shared";
+import { generateAppName } from "./utils";
+
+export const redis = pgTable("redis", {
+	redisId: text("redisId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	name: text("name").notNull(),
+	appName: text("appName")
+		.notNull()
+		.$defaultFn(() => generateAppName("redis"))
+		.unique(),
+	description: text("description"),
+	databasePassword: text("password").notNull(),
+	dockerImage: text("dockerImage").notNull(),
+	command: text("command"),
+	env: text("env"),
+	memoryReservation: integer("memoryReservation"),
+	memoryLimit: integer("memoryLimit"),
+	cpuReservation: integer("cpuReservation"),
+	cpuLimit: integer("cpuLimit"),
+	externalPort: integer("externalPort"),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+	applicationStatus: applicationStatus("applicationStatus")
+		.notNull()
+		.default("idle"),
+	projectId: text("projectId")
+		.notNull()
+		.references(() => projects.projectId, { onDelete: "cascade" }),
+	serverId: text("serverId").references(() => server.serverId, {
+		onDelete: "cascade",
+	}),
+});
+
+export const redisRelations = relations(redis, ({ one, many }) => ({
+	project: one(projects, {
+		fields: [redis.projectId],
+		references: [projects.projectId],
+	}),
+	mounts: many(mounts),
+	server: one(server, {
+		fields: [redis.serverId],
+		references: [server.serverId],
+	}),
+}));
+
+const createSchema = createInsertSchema(redis, {
+	redisId: z.string(),
+	appName: z.string().min(1),
+	createdAt: z.string(),
+	name: z.string().min(1),
+	databasePassword: z.string(),
+	dockerImage: z.string().default("redis:8"),
+	command: z.string().optional(),
+	env: z.string().optional(),
+	memoryReservation: z.number().optional(),
+	memoryLimit: z.number().optional(),
+	cpuReservation: z.number().optional(),
+	cpuLimit: z.number().optional(),
+	projectId: z.string(),
+	applicationStatus: z.enum(["idle", "running", "done", "error"]),
+	externalPort: z.number(),
+	description: z.string().optional(),
+	serverId: z.string().optional(),
+});
+
+export const apiCreateRedis = createSchema
+	.pick({
+		name: true,
+		appName: true,
+		databasePassword: true,
+		dockerImage: true,
+		projectId: true,
+		description: true,
+		serverId: true,
+	})
+	.required();
+
+export const apiFindOneRedis = createSchema
+	.pick({
+		redisId: true,
+	})
+	.required();
+
+export const apiChangeRedisStatus = createSchema
+	.pick({
+		redisId: true,
+		applicationStatus: true,
+	})
+	.required();
+
+export const apiSaveEnvironmentVariablesRedis = createSchema
+	.pick({
+		redisId: true,
+		env: true,
+	})
+	.required();
+
+export const apiSaveExternalPortRedis = createSchema
+	.pick({
+		redisId: true,
+		externalPort: true,
+	})
+	.required();
+
+export const apiDeployRedis = createSchema
+	.pick({
+		redisId: true,
+	})
+	.required();
+
+export const apiResetRedis = createSchema
+	.pick({
+		redisId: true,
+		appName: true,
+	})
+	.required();
+
+export const apiUpdateRedis = createSchema
+	.partial()
+	.extend({
+		redisId: z.string().min(1),
+	})
+	.omit({ serverId: true });
--- a/packages/server/src/db/schema/registry.ts
+++ b/packages/server/src/db/schema/registry.ts
@@ -0,0 +1,103 @@
+import { relations, sql } from "drizzle-orm";
+import { boolean, pgEnum, pgTable, text, timestamp } 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 { 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.
+ *
+ * @see https://orm.drizzle.team/docs/goodies#multi-project-schema
+ */
+export const registryType = pgEnum("RegistryType", ["selfHosted", "cloud"]);
+
+export const registry = pgTable("registry", {
+	registryId: text("registryId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	registryName: text("registryName").notNull(),
+	imagePrefix: text("imagePrefix"),
+	username: text("username").notNull(),
+	password: text("password").notNull(),
+	registryUrl: text("registryUrl").notNull().default(""),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+	registryType: registryType("selfHosted").notNull().default("cloud"),
+	adminId: text("adminId")
+		.notNull()
+		.references(() => admins.adminId, { onDelete: "cascade" }),
+});
+
+export const registryRelations = relations(registry, ({ one, many }) => ({
+	admin: one(admins, {
+		fields: [registry.adminId],
+		references: [admins.adminId],
+	}),
+	applications: many(applications),
+}));
+
+const createSchema = createInsertSchema(registry, {
+	registryName: z.string().min(1),
+	username: z.string().min(1),
+	password: z.string().min(1),
+	registryUrl: z.string(),
+	adminId: z.string().min(1),
+	registryId: z.string().min(1),
+	registryType: z.enum(["selfHosted", "cloud"]),
+	imagePrefix: z.string().nullable().optional(),
+});
+
+export const apiCreateRegistry = createSchema
+	.pick({})
+	.extend({
+		registryName: z.string().min(1),
+		username: z.string().min(1),
+		password: z.string().min(1),
+		registryUrl: z.string(),
+		registryType: z.enum(["selfHosted", "cloud"]),
+		imagePrefix: z.string().nullable().optional(),
+	})
+	.required()
+	.extend({
+		serverId: z.string().optional(),
+	});
+
+export const apiTestRegistry = createSchema.pick({}).extend({
+	registryName: z.string().min(1),
+	username: z.string().min(1),
+	password: z.string().min(1),
+	registryUrl: z.string(),
+	registryType: z.enum(["selfHosted", "cloud"]),
+	imagePrefix: z.string().nullable().optional(),
+	serverId: z.string().optional(),
+});
+
+export const apiRemoveRegistry = createSchema
+	.pick({
+		registryId: true,
+	})
+	.required();
+
+export const apiFindOneRegistry = createSchema
+	.pick({
+		registryId: true,
+	})
+	.required();
+
+export const apiUpdateRegistry = createSchema.partial().extend({
+	registryId: z.string().min(1),
+	serverId: z.string().optional(),
+});
+
+export const apiEnableSelfHostedRegistry = createSchema
+	.pick({
+		registryUrl: true,
+		username: true,
+		password: true,
+	})
+	.required();
--- a/packages/server/src/db/schema/security.ts
+++ b/packages/server/src/db/schema/security.ts
@@ -0,0 +1,61 @@
+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 { applications } from "./application";
+
+export const security = pgTable(
+	"security",
+	{
+		securityId: text("securityId")
+			.notNull()
+			.primaryKey()
+			.$defaultFn(() => nanoid()),
+		username: text("username").notNull(),
+		password: text("password").notNull(),
+		createdAt: text("createdAt")
+			.notNull()
+			.$defaultFn(() => new Date().toISOString()),
+		applicationId: text("applicationId")
+			.notNull()
+			.references(() => applications.applicationId, { onDelete: "cascade" }),
+	},
+	(t) => ({
+		unq: unique().on(t.username, t.applicationId),
+	}),
+);
+
+export const securityRelations = relations(security, ({ one }) => ({
+	application: one(applications, {
+		fields: [security.applicationId],
+		references: [applications.applicationId],
+	}),
+}));
+const createSchema = createInsertSchema(security, {
+	securityId: z.string().min(1),
+	username: z.string().min(1),
+	password: z.string().min(1),
+});
+
+export const apiFindOneSecurity = createSchema
+	.pick({
+		securityId: true,
+	})
+	.required();
+
+export const apiCreateSecurity = createSchema
+	.pick({
+		applicationId: true,
+		username: true,
+		password: true,
+	})
+	.required();
+
+export const apiUpdateSecurity = createSchema
+	.pick({
+		securityId: true,
+		username: true,
+		password: true,
+	})
+	.required();
--- a/packages/server/src/db/schema/server.ts
+++ b/packages/server/src/db/schema/server.ts
@@ -0,0 +1,102 @@
+import { relations } from "drizzle-orm";
+import { boolean, integer, 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 { deployments } from "./deployment";
+import { mariadb } from "./mariadb";
+import { mongo } from "./mongo";
+import { mysql } from "./mysql";
+import { postgres } from "./postgres";
+import { redis } from "./redis";
+import { sshKeys } from "./ssh-key";
+import { generateAppName } from "./utils";
+
+export const server = pgTable("server", {
+	serverId: text("serverId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	name: text("name").notNull(),
+	description: text("description"),
+	ipAddress: text("ipAddress").notNull(),
+	port: integer("port").notNull(),
+	username: text("username").notNull().default("root"),
+	appName: text("appName")
+		.notNull()
+		.$defaultFn(() => generateAppName("server")),
+	enableDockerCleanup: boolean("enableDockerCleanup").notNull().default(false),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+	adminId: text("adminId")
+		.notNull()
+		.references(() => admins.adminId, { onDelete: "cascade" }),
+	sshKeyId: text("sshKeyId").references(() => sshKeys.sshKeyId, {
+		onDelete: "set null",
+	}),
+});
+
+export const serverRelations = relations(server, ({ one, many }) => ({
+	admin: one(admins, {
+		fields: [server.adminId],
+		references: [admins.adminId],
+	}),
+	deployments: many(deployments),
+	sshKey: one(sshKeys, {
+		fields: [server.sshKeyId],
+		references: [sshKeys.sshKeyId],
+	}),
+	applications: many(applications),
+	compose: many(compose),
+	redis: many(redis),
+	mariadb: many(mariadb),
+	mongo: many(mongo),
+	mysql: many(mysql),
+	postgres: many(postgres),
+}));
+
+const createSchema = createInsertSchema(server, {
+	serverId: z.string().min(1),
+	name: z.string().min(1),
+	description: z.string().optional(),
+});
+
+export const apiCreateServer = createSchema
+	.pick({
+		name: true,
+		description: true,
+		ipAddress: true,
+		port: true,
+		username: true,
+		sshKeyId: true,
+	})
+	.required();
+
+export const apiFindOneServer = createSchema
+	.pick({
+		serverId: true,
+	})
+	.required();
+
+export const apiRemoveServer = createSchema
+	.pick({
+		serverId: true,
+	})
+	.required();
+
+export const apiUpdateServer = createSchema
+	.pick({
+		name: true,
+		description: true,
+		serverId: true,
+		ipAddress: true,
+		port: true,
+		username: true,
+		sshKeyId: true,
+	})
+	.required();
--- a/packages/server/src/db/schema/session.ts
+++ b/packages/server/src/db/schema/session.ts
@@ -0,0 +1,13 @@
+import { pgTable, text, timestamp } from "drizzle-orm/pg-core";
+import { auth } from "./auth";
+
+export const sessionTable = pgTable("session", {
+	id: text("id").primaryKey(),
+	userId: text("user_id")
+		.notNull()
+		.references(() => auth.id, { onDelete: "cascade" }),
+	expiresAt: timestamp("expires_at", {
+		withTimezone: true,
+		mode: "date",
+	}).notNull(),
+});
--- a/packages/server/src/db/schema/shared.ts
+++ b/packages/server/src/db/schema/shared.ts
@@ -0,0 +1,13 @@
+import { pgEnum } from "drizzle-orm/pg-core";
+
+export const applicationStatus = pgEnum("applicationStatus", [
+	"idle",
+	"running",
+	"done",
+	"error",
+]);
+
+export const certificateType = pgEnum("certificateType", [
+	"letsencrypt",
+	"none",
+]);
--- a/packages/server/src/db/schema/source.ts
+++ b/packages/server/src/db/schema/source.ts
@@ -0,0 +1,27 @@
+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")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	name: text("name").notNull(),
+	description: text("description"),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+});
+
+const createSchema = createInsertSchema(source, {
+	name: z.string().min(1),
+	description: z.string(),
+	projectId: z.string(),
+});
+
+export const apiCreate = createSchema.pick({
+	name: true,
+	description: true,
+});
--- a/packages/server/src/db/schema/ssh-key.ts
+++ b/packages/server/src/db/schema/ssh-key.ts
@@ -0,0 +1,82 @@
+import { relations } from "drizzle-orm";
+import { pgTable, text } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { sshKeyCreate, sshKeyType } from "../validations";
+import { admins } from "./admin";
+import { applications } from "./application";
+import { compose } from "./compose";
+import { server } from "./server";
+
+export const sshKeys = pgTable("ssh-key", {
+	sshKeyId: text("sshKeyId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	privateKey: text("privateKey").notNull().default(""),
+	publicKey: text("publicKey").notNull(),
+	name: text("name").notNull(),
+	description: text("description"),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+	lastUsedAt: text("lastUsedAt"),
+	adminId: text("adminId").references(() => admins.adminId, {
+		onDelete: "cascade",
+	}),
+});
+
+export const sshKeysRelations = relations(sshKeys, ({ many, one }) => ({
+	applications: many(applications),
+	compose: many(compose),
+	servers: many(server),
+	admin: one(admins, {
+		fields: [sshKeys.adminId],
+		references: [admins.adminId],
+	}),
+}));
+
+const createSchema = createInsertSchema(
+	sshKeys,
+	/* Private key is not stored in the DB */
+	sshKeyCreate.omit({ privateKey: true }).shape,
+);
+
+export const apiCreateSshKey = createSchema
+	.pick({
+		name: true,
+		description: true,
+		privateKey: true,
+		publicKey: true,
+		adminId: true,
+	})
+	.merge(sshKeyCreate.pick({ privateKey: true }));
+
+export const apiFindOneSshKey = createSchema
+	.pick({
+		sshKeyId: true,
+	})
+	.required();
+
+export const apiGenerateSSHKey = sshKeyType;
+
+export const apiRemoveSshKey = createSchema
+	.pick({
+		sshKeyId: true,
+	})
+	.required();
+
+export const apiUpdateSshKey = createSchema
+	.pick({
+		name: true,
+		description: true,
+		lastUsedAt: true,
+	})
+	.partial()
+	.merge(
+		createSchema
+			.pick({
+				sshKeyId: true,
+			})
+			.required(),
+	);
--- a/packages/server/src/db/schema/user.ts
+++ b/packages/server/src/db/schema/user.ts
@@ -0,0 +1,129 @@
+import { relations, sql } from "drizzle-orm";
+import { boolean, pgTable, text, timestamp } from "drizzle-orm/pg-core";
+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.
+ *
+ * @see https://orm.drizzle.team/docs/goodies#multi-project-schema
+ */
+
+export const users = pgTable("user", {
+	userId: text("userId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+
+	token: text("token").notNull(),
+	isRegistered: boolean("isRegistered").notNull().default(false),
+	expirationDate: timestamp("expirationDate", {
+		precision: 3,
+		mode: "string",
+	}).notNull(),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+	canCreateProjects: boolean("canCreateProjects").notNull().default(false),
+	canAccessToSSHKeys: boolean("canAccessToSSHKeys").notNull().default(false),
+	canCreateServices: boolean("canCreateServices").notNull().default(false),
+	canDeleteProjects: boolean("canDeleteProjects").notNull().default(false),
+	canDeleteServices: boolean("canDeleteServices").notNull().default(false),
+	canAccessToDocker: boolean("canAccessToDocker").notNull().default(false),
+	canAccessToAPI: boolean("canAccessToAPI").notNull().default(false),
+	canAccessToGitProviders: boolean("canAccessToGitProviders")
+		.notNull()
+		.default(false),
+	canAccessToTraefikFiles: boolean("canAccessToTraefikFiles")
+		.notNull()
+		.default(false),
+	accesedProjects: text("accesedProjects")
+		.array()
+		.notNull()
+		.default(sql`ARRAY[]::text[]`),
+	accesedServices: text("accesedServices")
+		.array()
+		.notNull()
+		.default(sql`ARRAY[]::text[]`),
+	adminId: text("adminId")
+		.notNull()
+		.references(() => admins.adminId, { onDelete: "cascade" }),
+	authId: text("authId")
+		.notNull()
+		.references(() => auth.id, { onDelete: "cascade" }),
+});
+
+export const usersRelations = relations(users, ({ one }) => ({
+	auth: one(auth, {
+		fields: [users.authId],
+		references: [auth.id],
+	}),
+	admin: one(admins, {
+		fields: [users.adminId],
+		references: [admins.adminId],
+	}),
+}));
+
+const createSchema = createInsertSchema(users, {
+	userId: z.string().min(1),
+	authId: z.string().min(1),
+	token: z.string().min(1),
+	isRegistered: z.boolean().optional(),
+	adminId: z.string(),
+	accesedProjects: z.array(z.string()).optional(),
+	accesedServices: z.array(z.string()).optional(),
+	canCreateProjects: z.boolean().optional(),
+	canCreateServices: z.boolean().optional(),
+	canDeleteProjects: z.boolean().optional(),
+	canDeleteServices: z.boolean().optional(),
+	canAccessToDocker: z.boolean().optional(),
+	canAccessToTraefikFiles: z.boolean().optional(),
+});
+
+export const apiCreateUserInvitation = createSchema.pick({}).extend({
+	email: z.string().email(),
+});
+
+export const apiRemoveUser = createSchema
+	.pick({
+		authId: true,
+	})
+	.required();
+
+export const apiFindOneToken = createSchema
+	.pick({
+		token: true,
+	})
+	.required();
+
+export const apiAssignPermissions = createSchema
+	.pick({
+		userId: true,
+		canCreateProjects: true,
+		canCreateServices: true,
+		canDeleteProjects: true,
+		canDeleteServices: true,
+		accesedProjects: true,
+		accesedServices: true,
+		canAccessToTraefikFiles: true,
+		canAccessToDocker: true,
+		canAccessToAPI: true,
+		canAccessToSSHKeys: true,
+		canAccessToGitProviders: true,
+	})
+	.required();
+
+export const apiFindOneUser = createSchema
+	.pick({
+		userId: true,
+	})
+	.required();
+
+export const apiFindOneUserByAuth = createSchema
+	.pick({
+		authId: true,
+	})
+	.required();
--- a/packages/server/src/db/schema/utils.ts
+++ b/packages/server/src/db/schema/utils.ts
@@ -0,0 +1,15 @@
+import { faker } from "@faker-js/faker";
+import { customAlphabet } from "nanoid";
+
+const alphabet = "abcdefghijklmnopqrstuvwxyz123456789";
+
+const customNanoid = customAlphabet(alphabet, 6);
+
+export const generateAppName = (type: string) => {
+	const verb = faker.hacker.verb().replace(/ /g, "-");
+	const adjective = faker.hacker.adjective().replace(/ /g, "-");
+	const noun = faker.hacker.noun().replace(/ /g, "-");
+	const randomFakerElement = `${verb}-${adjective}-${noun}`;
+	const nanoidPart = customNanoid();
+	return `${type}-${randomFakerElement}-${nanoidPart}`;
+};
--- a/packages/server/src/db/seed.ts
+++ b/packages/server/src/db/seed.ts
@@ -0,0 +1,35 @@
+// import bc from "bcrypt";
+// import { drizzle } from "drizzle-orm/postgres-js";
+// import postgres from "postgres";
+// import { users } from "./schema";
+
+// const connectionString = process.env.DATABASE_URL || "";
+
+// const pg = postgres(connectionString, { max: 1 });
+// const db = drizzle(pg);
+
+// function password(txt: string) {
+// 	return bc.hashSync(txt, 10);
+// }
+
+// async function seed() {
+// 	console.log("> Seed:", process.env.DATABASE_PATH, "\n");
+
+// 	// const authenticationR = await db
+// 	// 	.insert(users)
+// 	// 	.values([
+// 	// 		{
+// 	// 			email: "user1@hotmail.com",
+// 	// 			password: password("12345671"),
+// 	// 		},
+// 	// 	])
+// 	// 	.onConflictDoNothing()
+// 	// 	.returning();
+
+// 	// console.log("\nSemillas Update:", authenticationR.length);
+// }
+
+// seed().catch((e) => {
+// 	console.error(e);
+// 	process.exit(1);
+// });
--- a/packages/server/src/db/validations/domain.ts
+++ b/packages/server/src/db/validations/domain.ts
@@ -0,0 +1,46 @@
+import { z } from "zod";
+
+export const domain = z
+	.object({
+		host: z.string().min(1, { message: "Add a hostname" }),
+		path: z.string().min(1).optional(),
+		port: z
+			.number()
+			.min(1, { message: "Port must be at least 1" })
+			.max(65535, { message: "Port must be 65535 or below" })
+			.optional(),
+		https: z.boolean().optional(),
+		certificateType: z.enum(["letsencrypt", "none"]).optional(),
+	})
+	.superRefine((input, ctx) => {
+		if (input.https && !input.certificateType) {
+			ctx.addIssue({
+				code: z.ZodIssueCode.custom,
+				path: ["certificateType"],
+				message: "Required",
+			});
+		}
+	});
+
+export const domainCompose = z
+	.object({
+		host: z.string().min(1, { message: "Host is required" }),
+		path: z.string().min(1).optional(),
+		port: z
+			.number()
+			.min(1, { message: "Port must be at least 1" })
+			.max(65535, { message: "Port must be 65535 or below" })
+			.optional(),
+		https: z.boolean().optional(),
+		certificateType: z.enum(["letsencrypt", "none"]).optional(),
+		serviceName: z.string().min(1, { message: "Service name is required" }),
+	})
+	.superRefine((input, ctx) => {
+		if (input.https && !input.certificateType) {
+			ctx.addIssue({
+				code: z.ZodIssueCode.custom,
+				path: ["certificateType"],
+				message: "Required",
+			});
+		}
+	});
--- a/packages/server/src/db/validations/index.ts
+++ b/packages/server/src/db/validations/index.ts
@@ -0,0 +1,37 @@
+import { z } from "zod";
+
+export const sshKeyCreate = z.object({
+	name: z.string().min(1),
+	description: z.string().optional(),
+	publicKey: z.string().refine(
+		(key) => {
+			const rsaPubPattern = /^ssh-rsa\s+([A-Za-z0-9+/=]+)\s*(.*)?\s*$/;
+			const ed25519PubPattern = /^ssh-ed25519\s+([A-Za-z0-9+/=]+)\s*(.*)?\s*$/;
+			return rsaPubPattern.test(key) || ed25519PubPattern.test(key);
+		},
+		{
+			message: "Invalid public key format",
+		},
+	),
+	privateKey: z.string().refine(
+		(key) => {
+			const rsaPrivPattern =
+				/^-----BEGIN RSA PRIVATE KEY-----\n([A-Za-z0-9+/=\n]+)-----END RSA PRIVATE KEY-----\s*$/;
+			const ed25519PrivPattern =
+				/^-----BEGIN OPENSSH PRIVATE KEY-----\n([A-Za-z0-9+/=\n]+)-----END OPENSSH PRIVATE KEY-----\s*$/;
+			return rsaPrivPattern.test(key) || ed25519PrivPattern.test(key);
+		},
+		{
+			message: "Invalid private key format",
+		},
+	),
+});
+
+export const sshKeyUpdate = sshKeyCreate.pick({
+	name: true,
+	description: true,
+});
+
+export const sshKeyType = z.object({
+	type: z.enum(["rsa", "ed25519"]).optional(),
+});