Merge branch 'canary' into hehehai/feat-server-custom-name

server/db/drizzle.config.ts

@@ -1,13 +1,14 @@
-import type { Config } from "drizzle-kit";
+import { defineConfig } from "drizzle-kit";
 
-console.log("> Generating PG Schema:", process.env.DATABASE_URL);
-export default {
+export default defineConfig({
 	schema: "./server/db/schema/index.ts",
-	driver: "pg",
+	dialect: "postgresql",
 	dbCredentials: {
-		connectionString: process.env.DATABASE_URL || "",
+		url: process.env.DATABASE_URL || "",
 	},
-	verbose: true,
-	strict: true,
 	out: "drizzle",
-} satisfies Config;
+	migrations: {
+		table: "migrations",
+		schema: "public",
+	},
+});

server/db/schema/admin.ts

@@ -6,6 +6,7 @@ import { users } from "./user";
 import { createInsertSchema } from "drizzle-zod";
 import { z } from "zod";
 import { certificateType } from "./shared";
+import { registry } from "./registry";
 
 export const admins = pgTable("admin", {
 	adminId: text("adminId")
@@ -39,6 +40,7 @@ export const adminsRelations = relations(admins, ({ one, many }) => ({
 		references: [auth.id],
 	}),
 	users: many(users),
+	registry: many(registry),
 }));
 
 const createSchema = createInsertSchema(admins, {

server/db/schema/application.ts

@@ -10,8 +10,16 @@ import { projects } from "./project";
 import { security } from "./security";
 import { applicationStatus } from "./shared";
 import { ports } from "./port";
-import { boolean, integer, pgEnum, pgTable, text } from "drizzle-orm/pg-core";
+import {
+	boolean,
+	integer,
+	json,
+	pgEnum,
+	pgTable,
+	text,
+} from "drizzle-orm/pg-core";
 import { generateAppName } from "./utils";
+import { registry } from "./registry";
 
 export const sourceType = pgEnum("sourceType", ["docker", "git", "github"]);
 
@@ -22,6 +30,65 @@ export const buildType = pgEnum("buildType", [
 	"nixpacks",
 ]);
 
+// TODO: refactor this types
+interface HealthCheckSwarm {
+	Test?: string[] | undefined;
+	Interval?: number | undefined;
+	Timeout?: number | undefined;
+	StartPeriod?: number | undefined;
+	Retries?: number | undefined;
+}
+
+interface RestartPolicySwarm {
+	Condition?: string | undefined;
+	Delay?: number | undefined;
+	MaxAttempts?: number | undefined;
+	Window?: number | undefined;
+}
+
+interface PlacementSwarm {
+	Constraints?: string[] | undefined;
+	Preferences?: Array<{ Spread: { SpreadDescriptor: string } }> | undefined;
+	MaxReplicas?: number | undefined;
+	Platforms?:
+		| Array<{
+				Architecture: string;
+				OS: string;
+		  }>
+		| undefined;
+}
+
+interface UpdateConfigSwarm {
+	Parallelism: number;
+	Delay?: number | undefined;
+	FailureAction?: string | undefined;
+	Monitor?: number | undefined;
+	MaxFailureRatio?: number | undefined;
+	Order: string;
+}
+
+interface ServiceModeSwarm {
+	Replicated?: { Replicas?: number | undefined } | undefined;
+	Global?: {} | undefined;
+	ReplicatedJob?:
+		| {
+				MaxConcurrent?: number | undefined;
+				TotalCompletions?: number | undefined;
+		  }
+		| undefined;
+	GlobalJob?: {} | undefined;
+}
+
+interface NetworkSwarm {
+	Target?: string | undefined;
+	Aliases?: string[] | undefined;
+	DriverOpts?: { [key: string]: string } | undefined;
+}
+
+interface LabelsSwarm {
+	[name: string]: string;
+}
+
 export const applications = pgTable("application", {
 	applicationId: text("applicationId")
 		.notNull()
@@ -60,6 +127,17 @@ export const applications = pgTable("application", {
 	customGitBuildPath: text("customGitBuildPath"),
 	customGitSSHKey: text("customGitSSHKey"),
 	dockerfile: text("dockerfile"),
+	// 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"),
@@ -67,6 +145,9 @@ export const applications = pgTable("application", {
 	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" }),
@@ -85,9 +166,101 @@ export const applicationsRelations = relations(
 		redirects: many(redirects),
 		security: many(security),
 		ports: many(ports),
+		registry: one(registry, {
+			fields: [applications.registryId],
+			references: [registry.registryId],
+		}),
 	}),
 );
 
+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(),
@@ -124,6 +297,14 @@ const createSchema = createInsertSchema(applications, {
 		"nixpacks",
 	]),
 	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({

server/db/schema/compose.ts

@@ -0,0 +1,109 @@
+import { createInsertSchema } from "drizzle-zod";
+import { z } from "zod";
+import { nanoid } from "nanoid";
+import { boolean, pgEnum, pgTable, text } from "drizzle-orm/pg-core";
+import { projects } from "./project";
+import { relations } from "drizzle-orm";
+import { deployments } from "./deployment";
+import { generateAppName } from "./utils";
+import { applicationStatus } from "./shared";
+import { mounts } from "./mount";
+
+export const sourceTypeCompose = pgEnum("sourceTypeCompose", [
+	"git",
+	"github",
+	"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"),
+	// Git
+	customGitUrl: text("customGitUrl"),
+	customGitBranch: text("customGitBranch"),
+	customGitSSHKey: text("customGitSSHKey"),
+	//
+	command: text("command").notNull().default(""),
+	//
+	composePath: text("composePath").notNull().default("./docker-compose.yml"),
+	composeStatus: applicationStatus("composeStatus").notNull().default("idle"),
+	projectId: text("projectId")
+		.notNull()
+		.references(() => projects.projectId, { onDelete: "cascade" }),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+});
+
+export const composeRelations = relations(compose, ({ one, many }) => ({
+	project: one(projects, {
+		fields: [compose.projectId],
+		references: [projects.projectId],
+	}),
+	deployments: many(deployments),
+	mounts: many(mounts),
+}));
+
+const createSchema = createInsertSchema(compose, {
+	name: z.string().min(1),
+	description: z.string(),
+	env: z.string().optional(),
+	composeFile: z.string().min(1),
+	projectId: z.string(),
+	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,
+});
+
+export const apiCreateComposeByTemplate = createSchema
+	.pick({
+		projectId: true,
+	})
+	.extend({
+		id: z.string().min(1),
+	});
+
+export const apiFindCompose = z.object({
+	composeId: z.string().min(1),
+});
+
+export const apiUpdateCompose = createSchema.partial().extend({
+	composeId: z.string(),
+	composeFile: z.string().optional(),
+	command: z.string().optional(),
+});
+
+export const apiRandomizeCompose = createSchema
+	.pick({
+		composeId: true,
+	})
+	.extend({
+		prefix: z.string().optional(),
+		composeId: z.string().min(1),
+	});

server/db/schema/deployment.ts

@@ -4,6 +4,7 @@ import { nanoid } from "nanoid";
 import { applications } from "./application";
 import { createInsertSchema } from "drizzle-zod";
 import { pgEnum, pgTable, text } from "drizzle-orm/pg-core";
+import { compose } from "./compose";
 
 export const deploymentStatus = pgEnum("deploymentStatus", [
 	"running",
@@ -19,9 +20,13 @@ export const deployments = pgTable("deployment", {
 	title: text("title").notNull(),
 	status: deploymentStatus("status").default("running"),
 	logPath: text("logPath").notNull(),
-	applicationId: text("applicationId")
-		.notNull()
-		.references(() => applications.applicationId, { onDelete: "cascade" }),
+	applicationId: text("applicationId").references(
+		() => applications.applicationId,
+		{ onDelete: "cascade" },
+	),
+	composeId: text("composeId").references(() => compose.composeId, {
+		onDelete: "cascade",
+	}),
 	createdAt: text("createdAt")
 		.notNull()
 		.$defaultFn(() => new Date().toISOString()),
@@ -32,13 +37,18 @@ export const deploymentsRelations = relations(deployments, ({ one }) => ({
 		fields: [deployments.applicationId],
 		references: [applications.applicationId],
 	}),
+	compose: one(compose, {
+		fields: [deployments.composeId],
+		references: [compose.composeId],
+	}),
 }));
 
 const schema = createInsertSchema(deployments, {
 	title: z.string().min(1),
 	status: z.string().default("running"),
 	logPath: z.string().min(1),
-	applicationId: z.string().min(1),
+	applicationId: z.string(),
+	composeId: z.string(),
 });
 
 export const apiCreateDeployment = schema
@@ -48,10 +58,35 @@ export const apiCreateDeployment = schema
 		logPath: true,
 		applicationId: true,
 	})
-	.required();
+	.extend({
+		applicationId: z.string().min(1),
+	});
+
+export const apiCreateDeploymentCompose = schema
+	.pick({
+		title: true,
+		status: true,
+		logPath: true,
+		composeId: true,
+	})
+	.extend({
+		composeId: 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();

server/db/schema/index.ts

@@ -1,6 +1,5 @@
 export * from "./application";
 export * from "./postgres";
-
 export * from "./user";
 export * from "./admin";
 export * from "./auth";
@@ -20,3 +19,5 @@ export * from "./security";
 export * from "./port";
 export * from "./redis";
 export * from "./shared";
+export * from "./compose";
+export * from "./registry";

server/db/schema/mount.ts

@@ -9,6 +9,7 @@ import { mariadb } from "./mariadb";
 import { mongo } from "./mongo";
 import { mysql } from "./mysql";
 import { redis } from "./redis";
+import { compose } from "./compose";
 
 export const serviceType = pgEnum("serviceType", [
 	"application",
@@ -17,6 +18,7 @@ export const serviceType = pgEnum("serviceType", [
 	"mariadb",
 	"mongo",
 	"redis",
+	"compose",
 ]);
 
 export const mountType = pgEnum("mountType", ["bind", "volume", "file"]);
@@ -51,6 +53,9 @@ export const mounts = pgTable("mount", {
 	redisId: text("redisId").references(() => redis.redisId, {
 		onDelete: "cascade",
 	}),
+	composeId: text("composeId").references(() => compose.composeId, {
+		onDelete: "cascade",
+	}),
 });
 
 export const MountssRelations = relations(mounts, ({ one }) => ({
@@ -78,6 +83,10 @@ export const MountssRelations = relations(mounts, ({ one }) => ({
 		fields: [mounts.redisId],
 		references: [redis.redisId],
 	}),
+	compose: one(compose, {
+		fields: [mounts.composeId],
+		references: [compose.composeId],
+	}),
 }));
 
 const createSchema = createInsertSchema(mounts, {
@@ -89,7 +98,15 @@ const createSchema = createInsertSchema(mounts, {
 	mountPath: z.string().min(1),
 	mountId: z.string().optional(),
 	serviceType: z
-		.enum(["application", "postgres", "mysql", "mariadb", "mongo", "redis"])
+		.enum([
+			"application",
+			"postgres",
+			"mysql",
+			"mariadb",
+			"mongo",
+			"redis",
+			"compose",
+		])
 		.default("application"),
 });
 
@@ -134,3 +151,7 @@ export const apiFindMountByApplicationId = createSchema
 		serviceType: true,
 	})
 	.required();
+
+export const apiUpdateMount = createSchema.partial().extend({
+	mountId: z.string().min(1),
+});

server/db/schema/project.ts

@@ -11,6 +11,7 @@ import { applications } from "./application";
 import { mongo } from "./mongo";
 import { redis } from "./redis";
 import { admins } from "./admin";
+import { compose } from "./compose";
 
 export const projects = pgTable("project", {
 	projectId: text("projectId")
@@ -34,6 +35,7 @@ export const projectRelations = relations(projects, ({ many, one }) => ({
 	applications: many(applications),
 	mongo: many(mongo),
 	redis: many(redis),
+	compose: many(compose),
 	admin: one(admins, {
 		fields: [projects.adminId],
 		references: [admins.adminId],

server/db/schema/registry.ts

@@ -0,0 +1,98 @@
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { relations, sql } from "drizzle-orm";
+import { boolean, pgEnum, pgTable, text, timestamp } from "drizzle-orm/pg-core";
+import { auth } from "./auth";
+import { admins } from "./admin";
+import { z } from "zod";
+import { applications } from "./application";
+/**
+ * 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(),
+	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().min(1),
+	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();
+
+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(),
+});
+
+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),
+});
+
+export const apiEnableSelfHostedRegistry = createSchema
+	.pick({
+		registryUrl: true,
+		username: true,
+		password: true,
+	})
+	.required();