Merge branch 'canary' into feat/requests

apps/dokploy/server/db/schema/admin.ts

@@ -1,5 +1,5 @@
 import { relations } from "drizzle-orm";
-import { boolean, integer, pgTable, text } from "drizzle-orm/pg-core";
+import { boolean, pgTable, text } from "drizzle-orm/pg-core";
 import { createInsertSchema } from "drizzle-zod";
 import { nanoid } from "nanoid";
 import { z } from "zod";
@@ -13,17 +13,9 @@ export const admins = pgTable("admin", {
 		.notNull()
 		.primaryKey()
 		.$defaultFn(() => nanoid()),
-
-	githubAppId: integer("githubAppId"),
-	githubAppName: text("githubAppName"),
 	serverIp: text("serverIp"),
 	certificateType: certificateType("certificateType").notNull().default("none"),
 	host: text("host"),
-	githubClientId: text("githubClientId"),
-	githubClientSecret: text("githubClientSecret"),
-	githubInstallationId: text("githubInstallationId"),
-	githubPrivateKey: text("githubPrivateKey"),
-	githubWebhookSecret: text("githubWebhookSecret"),
 	letsEncryptEmail: text("letsEncryptEmail"),
 	sshPrivateKey: text("sshPrivateKey"),
 	enableDockerCleanup: boolean("enableDockerCleanup").notNull().default(false),
@@ -48,12 +40,6 @@ export const adminsRelations = relations(admins, ({ one, many }) => ({
 
 const createSchema = createInsertSchema(admins, {
 	adminId: z.string(),
-	githubAppName: z.string().optional(),
-	githubClientId: z.string().optional(),
-	githubClientSecret: z.string().optional(),
-	githubInstallationId: z.string().optional(),
-	githubPrivateKey: z.string().optional(),
-	githubAppId: z.number().optional(),
 	enableDockerCleanup: z.boolean().optional(),
 	sshPrivateKey: z.string().optional(),
 	certificateType: z.enum(["letsencrypt", "none"]).default("none"),
@@ -84,10 +70,6 @@ export const apiTraefikConfig = z.object({
 	traefikConfig: z.string().min(1),
 });
 
-export const apiGetBranches = z.object({
-	repo: z.string().min(1),
-	owner: z.string().min(1),
-});
 export const apiModifyTraefikConfig = z.object({
 	path: z.string().min(1),
 	traefikConfig: z.string().min(1),

apps/dokploy/server/db/schema/application.ts

@@ -1,4 +1,3 @@
-import { generatePassword } from "@/templates/utils";
 import { relations } from "drizzle-orm";
 import {
 	boolean,
@@ -11,6 +10,7 @@ import {
 import { createInsertSchema } from "drizzle-zod";
 import { nanoid } from "nanoid";
 import { z } from "zod";
+import { bitbucket, github, gitlab } from ".";
 import { deployments } from "./deployment";
 import { domains } from "./domain";
 import { mounts } from "./mount";
@@ -27,6 +27,8 @@ export const sourceType = pgEnum("sourceType", [
 	"docker",
 	"git",
 	"github",
+	"gitlab",
+	"bitbucket",
 	"drop",
 ]);
 
@@ -126,6 +128,18 @@ export const applications = pgTable("application", {
 	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"),
@@ -142,6 +156,7 @@ export const applications = pgTable("application", {
 	),
 	dockerfile: text("dockerfile"),
 	dockerContextPath: text("dockerContextPath"),
+	dockerBuildStage: text("dockerBuildStage"),
 	// Drop
 	dropBuildPath: text("dropBuildPath"),
 	// Docker swarm json
@@ -169,6 +184,15 @@ export const applications = pgTable("application", {
 	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",
+	}),
 });
 
 export const applicationsRelations = relations(
@@ -192,6 +216,18 @@ export const applicationsRelations = relations(
 			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],
+		}),
 	}),
 );
 
@@ -358,6 +394,7 @@ export const apiSaveBuildType = createSchema
 		buildType: true,
 		dockerfile: true,
 		dockerContextPath: true,
+		dockerBuildStage: true,
 	})
 	.required()
 	.merge(createSchema.pick({ publishDirectory: true }));
@@ -369,6 +406,31 @@ export const apiSaveGithubProvider = createSchema
 		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();
 

apps/dokploy/server/db/schema/auth.ts

@@ -70,6 +70,7 @@ export const apiCreateUser = createSchema
 	.pick({
 		password: true,
 		id: true,
+		token: true,
 	})
 	.required()
 	.extend({

apps/dokploy/server/db/schema/bitbucket.ts

@@ -0,0 +1,64 @@
+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(),
+});

apps/dokploy/server/db/schema/compose.ts

@@ -1,9 +1,10 @@
 import { sshKeys } from "@/server/db/schema/ssh-key";
 import { relations } from "drizzle-orm";
-import { boolean, pgEnum, pgTable, text } from "drizzle-orm/pg-core";
+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, github, gitlab } from ".";
 import { deployments } from "./deployment";
 import { domains } from "./domain";
 import { mounts } from "./mount";
@@ -14,6 +15,8 @@ import { generateAppName } from "./utils";
 export const sourceTypeCompose = pgEnum("sourceTypeCompose", [
 	"git",
 	"github",
+	"gitlab",
+	"bitbucket",
 	"raw",
 ]);
 
@@ -39,6 +42,16 @@ export const compose = pgTable("compose", {
 	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"),
@@ -48,10 +61,11 @@ export const compose = pgTable("compose", {
 			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()
@@ -59,6 +73,16 @@ export const compose = pgTable("compose", {
 	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",
+	}),
 });
 
 export const composeRelations = relations(compose, ({ one, many }) => ({
@@ -73,6 +97,18 @@ export const composeRelations = relations(compose, ({ one, many }) => ({
 		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],
+	}),
 }));
 
 const createSchema = createInsertSchema(compose, {
@@ -123,6 +159,6 @@ export const apiRandomizeCompose = createSchema
 		composeId: true,
 	})
 	.extend({
-		prefix: z.string().optional(),
+		suffix: z.string().optional(),
 		composeId: z.string().min(1),
 	});

apps/dokploy/server/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 { auth } from "./auth";
+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()),
+	authId: text("authId")
+		.notNull()
+		.references(() => auth.id, { 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],
+	}),
+	auth: one(auth, {
+		fields: [gitProvider.authId],
+		references: [auth.id],
+	}),
+}));
+
+const createSchema = createInsertSchema(gitProvider);
+
+export const apiRemoveGitProvider = createSchema
+	.extend({
+		gitProviderId: z.string().min(1),
+	})
+	.pick({ gitProviderId: true });

apps/dokploy/server/db/schema/github.ts

@@ -0,0 +1,62 @@
+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),
+	authId: 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),
+});

apps/dokploy/server/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),
+});

apps/dokploy/server/db/schema/index.ts

@@ -23,3 +23,7 @@ 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";

apps/dokploy/server/db/schema/user.ts

@@ -34,6 +34,9 @@ export const users = pgTable("user", {
 	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),
@@ -109,6 +112,7 @@ export const apiAssignPermissions = createSchema
 		canAccessToDocker: true,
 		canAccessToAPI: true,
 		canAccessToSSHKeys: true,
+		canAccessToGitProviders: true,
 	})
 	.required();