Merge branch 'canary' into feature/stop-grace-period-2227-alt

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

@@ -112,6 +112,10 @@ export const member = pgTable("member", {
 		.array()
 		.notNull()
 		.default(sql`ARRAY[]::text[]`),
+	accessedEnvironments: text("accessedEnvironments")
+		.array()
+		.notNull()
+		.default(sql`ARRAY[]::text[]`),
 	accessedServices: text("accesedServices")
 		.array()
 		.notNull()

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

@@ -32,7 +32,7 @@ export const aiRelations = relations(ai, ({ one }) => ({
 const createSchema = createInsertSchema(ai, {
 	name: z.string().min(1, { message: "Name is required" }),
 	apiUrl: z.string().url({ message: "Please enter a valid URL" }),
-	apiKey: z.string().min(1, { message: "API Key is required" }),
+	apiKey: z.string(),
 	model: z.string().min(1, { message: "Model is required" }),
 	isEnabled: z.boolean().optional(),
 });
@@ -55,7 +55,7 @@ export const apiUpdateAi = createSchema
 	.omit({ organizationId: true });
 
 export const deploySuggestionSchema = z.object({
-	projectId: z.string().min(1),
+	environmentId: z.string().min(1),
 	id: z.string().min(1),
 	dockerCompose: z.string().min(1),
 	envVariables: z.string(),

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

@@ -14,6 +14,7 @@ import { z } from "zod";
 import { bitbucket } from "./bitbucket";
 import { deployments } from "./deployment";
 import { domains } from "./domain";
+import { environments } from "./environment";
 import { gitea } from "./gitea";
 import { github } from "./github";
 import { gitlab } from "./gitlab";
@@ -80,6 +81,7 @@ export const applications = pgTable("application", {
 	previewEnv: text("previewEnv"),
 	watchPaths: text("watchPaths").array(),
 	previewBuildArgs: text("previewBuildArgs"),
+	previewLabels: text("previewLabels").array(),
 	previewWildcard: text("previewWildcard"),
 	previewPort: integer("previewPort").default(3000),
 	previewHttps: boolean("previewHttps").notNull().default(false),
@@ -180,9 +182,9 @@ export const applications = pgTable("application", {
 	registryId: text("registryId").references(() => registry.registryId, {
 		onDelete: "set null",
 	}),
-	projectId: text("projectId")
+	environmentId: text("environmentId")
 		.notNull()
-		.references(() => projects.projectId, { onDelete: "cascade" }),
+		.references(() => environments.environmentId, { onDelete: "cascade" }),
 	githubId: text("githubId").references(() => github.githubId, {
 		onDelete: "set null",
 	}),
@@ -203,9 +205,9 @@ export const applications = pgTable("application", {
 export const applicationsRelations = relations(
 	applications,
 	({ one, many }) => ({
-		project: one(projects, {
-			fields: [applications.projectId],
-			references: [projects.projectId],
+		environment: one(environments, {
+			fields: [applications.environmentId],
+			references: [environments.environmentId],
 		}),
 		deployments: many(deployments),
 		customGitSSHKey: one(sshKeys, {
@@ -274,7 +276,7 @@ const createSchema = createInsertSchema(applications, {
 	customGitBuildPath: z.string().optional(),
 	customGitUrl: z.string().optional(),
 	buildPath: z.string().optional(),
-	projectId: z.string(),
+	environmentId: z.string(),
 	sourceType: z
 		.enum(["github", "docker", "git", "gitlab", "bitbucket", "gitea", "drop"])
 		.optional(),
@@ -310,6 +312,7 @@ const createSchema = createInsertSchema(applications, {
 	previewCertificateType: z.enum(["letsencrypt", "none", "custom"]).optional(),
 	previewRequireCollaboratorPermissions: z.boolean().optional(),
 	watchPaths: z.array(z.string()).optional(),
+	previewLabels: z.array(z.string()).optional(),
 	cleanCache: z.boolean().optional(),
 	stopGracePeriodSwarm: z.bigint().nullable(),
 });
@@ -318,7 +321,7 @@ export const apiCreateApplication = createSchema.pick({
 	name: true,
 	appName: true,
 	description: true,
-	projectId: true,
+	environmentId: true,
 	serverId: true,
 });
 

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

@@ -7,17 +7,17 @@ import { backups } from "./backups";
 import { bitbucket } from "./bitbucket";
 import { deployments } from "./deployment";
 import { domains } from "./domain";
+import { environments } from "./environment";
 import { gitea } from "./gitea";
 import { github } from "./github";
 import { gitlab } from "./gitlab";
 import { mounts } from "./mount";
 import { projects } from "./project";
+import { schedules } from "./schedule";
 import { server } from "./server";
 import { applicationStatus, triggerType } from "./shared";
 import { sshKeys } from "./ssh-key";
 import { generateAppName } from "./utils";
-
-import { schedules } from "./schedule";
 export const sourceTypeCompose = pgEnum("sourceTypeCompose", [
 	"git",
 	"github",
@@ -85,9 +85,9 @@ export const compose = pgTable("compose", {
 		.default(false),
 	triggerType: triggerType("triggerType").default("push"),
 	composeStatus: applicationStatus("composeStatus").notNull().default("idle"),
-	projectId: text("projectId")
+	environmentId: text("environmentId")
 		.notNull()
-		.references(() => projects.projectId, { onDelete: "cascade" }),
+		.references(() => environments.environmentId, { onDelete: "cascade" }),
 	createdAt: text("createdAt")
 		.notNull()
 		.$defaultFn(() => new Date().toISOString()),
@@ -110,9 +110,9 @@ export const compose = pgTable("compose", {
 });
 
 export const composeRelations = relations(compose, ({ one, many }) => ({
-	project: one(projects, {
-		fields: [compose.projectId],
-		references: [projects.projectId],
+	environment: one(environments, {
+		fields: [compose.environmentId],
+		references: [environments.environmentId],
 	}),
 	deployments: many(deployments),
 	mounts: many(mounts),
@@ -150,7 +150,7 @@ const createSchema = createInsertSchema(compose, {
 	description: z.string(),
 	env: z.string().optional(),
 	composeFile: z.string().optional(),
-	projectId: z.string(),
+	environmentId: z.string(),
 	customGitSSHKeyId: z.string().optional(),
 	command: z.string().optional(),
 	composePath: z.string().min(1),
@@ -161,7 +161,7 @@ const createSchema = createInsertSchema(compose, {
 export const apiCreateCompose = createSchema.pick({
 	name: true,
 	description: true,
-	projectId: true,
+	environmentId: true,
 	composeType: true,
 	appName: true,
 	serverId: true,
@@ -170,7 +170,7 @@ export const apiCreateCompose = createSchema.pick({
 
 export const apiCreateComposeByTemplate = createSchema
 	.pick({
-		projectId: true,
+		environmentId: true,
 	})
 	.extend({
 		id: z.string().min(1),

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

@@ -0,0 +1,85 @@
+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 { applications } from "./application";
+import { compose } from "./compose";
+import { mariadb } from "./mariadb";
+import { mongo } from "./mongo";
+import { mysql } from "./mysql";
+import { postgres } from "./postgres";
+import { projects } from "./project";
+import { redis } from "./redis";
+
+export const environments = pgTable("environment", {
+	environmentId: text("environmentId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	name: text("name").notNull(),
+	description: text("description"),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+	env: text("env").notNull().default(""),
+	projectId: text("projectId")
+		.notNull()
+		.references(() => projects.projectId, { onDelete: "cascade" }),
+});
+
+export const environmentRelations = relations(
+	environments,
+	({ one, many }) => ({
+		project: one(projects, {
+			fields: [environments.projectId],
+			references: [projects.projectId],
+		}),
+		applications: many(applications),
+		mariadb: many(mariadb),
+		postgres: many(postgres),
+		mysql: many(mysql),
+		redis: many(redis),
+		mongo: many(mongo),
+		compose: many(compose),
+	}),
+);
+
+const createSchema = createInsertSchema(environments, {
+	environmentId: z.string().min(1),
+	name: z.string().min(1),
+	description: z.string().optional(),
+});
+
+export const apiCreateEnvironment = createSchema.pick({
+	name: true,
+	description: true,
+	projectId: true,
+});
+
+export const apiFindOneEnvironment = createSchema
+	.pick({
+		environmentId: true,
+	})
+	.required();
+
+export const apiRemoveEnvironment = createSchema
+	.pick({
+		environmentId: true,
+	})
+	.required();
+
+export const apiUpdateEnvironment = createSchema.partial().extend({
+	environmentId: z.string().min(1),
+});
+
+export const apiDuplicateEnvironment = createSchema
+	.pick({
+		environmentId: true,
+		name: true,
+		description: true,
+	})
+	.required({
+		environmentId: true,
+		name: true,
+	});

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

@@ -1,36 +1,37 @@
+export * from "./account";
+export * from "./ai";
 export * from "./application";
-export * from "./postgres";
-export * from "./user";
-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 "./certificate";
+export * from "./compose";
+export * from "./deployment";
+export * from "./destination";
+export * from "./domain";
+export * from "./environment";
+export * from "./git-provider";
+export * from "./gitea";
 export * from "./github";
 export * from "./gitlab";
-export * from "./gitea";
-export * from "./server";
-export * from "./utils";
+export * from "./mariadb";
+export * from "./mongo";
+export * from "./mount";
+export * from "./mysql";
+export * from "./notification";
+export * from "./port";
+export * from "./postgres";
 export * from "./preview-deployments";
-export * from "./ai";
-export * from "./account";
-export * from "./schedule";
+export * from "./project";
+export * from "./redirects";
+export * from "./redis";
+export * from "./registry";
 export * from "./rollbacks";
+export * from "./schedule";
+export * from "./security";
+export * from "./server";
+export * from "./session";
+export * from "./shared";
+export * from "./ssh-key";
+export * from "./user";
+export * from "./utils";
 export * from "./volume-backups";

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

@@ -4,8 +4,8 @@ import { createInsertSchema } from "drizzle-zod";
 import { nanoid } from "nanoid";
 import { z } from "zod";
 import { backups } from "./backups";
+import { environments } from "./environment";
 import { mounts } from "./mount";
-import { projects } from "./project";
 import { server } from "./server";
 import {
 	applicationStatus,
@@ -66,18 +66,19 @@ export const mariadb = pgTable("mariadb", {
 	createdAt: text("createdAt")
 		.notNull()
 		.$defaultFn(() => new Date().toISOString()),
-	projectId: text("projectId")
+
+	environmentId: text("environmentId")
 		.notNull()
-		.references(() => projects.projectId, { onDelete: "cascade" }),
+		.references(() => environments.environmentId, { 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],
+	environment: one(environments, {
+		fields: [mariadb.environmentId],
+		references: [environments.environmentId],
 	}),
 	backups: many(backups),
 	mounts: many(mounts),
@@ -94,8 +95,19 @@ const createSchema = createInsertSchema(mariadb, {
 	createdAt: z.string(),
 	databaseName: z.string().min(1),
 	databaseUser: z.string().min(1),
-	databasePassword: z.string(),
-	databaseRootPassword: z.string().optional(),
+	databasePassword: z
+		.string()
+		.regex(/^[a-zA-Z0-9@#%^&*()_+\-=[\]{}|;:,.<>?~`]*$/, {
+			message:
+				"Password contains invalid characters. Please avoid: $ ! ' \" \\ / and space characters for database compatibility",
+		}),
+	databaseRootPassword: z
+		.string()
+		.regex(/^[a-zA-Z0-9@#%^&*()_+\-=[\]{}|;:,.<>?~`]*$/, {
+			message:
+				"Password contains invalid characters. Please avoid: $ ! ' \" \\ / and space characters for database compatibility",
+		})
+		.optional(),
 	dockerImage: z.string().default("mariadb:6"),
 	command: z.string().optional(),
 	env: z.string().optional(),
@@ -103,7 +115,7 @@ const createSchema = createInsertSchema(mariadb, {
 	memoryLimit: z.string().optional(),
 	cpuReservation: z.string().optional(),
 	cpuLimit: z.string().optional(),
-	projectId: z.string(),
+	environmentId: z.string(),
 	applicationStatus: z.enum(["idle", "running", "done", "error"]),
 	externalPort: z.number(),
 	description: z.string().optional(),
@@ -124,7 +136,7 @@ export const apiCreateMariaDB = createSchema
 		appName: true,
 		dockerImage: true,
 		databaseRootPassword: true,
-		projectId: true,
+		environmentId: true,
 		description: true,
 		databaseName: true,
 		databaseUser: true,

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

@@ -4,8 +4,8 @@ import { createInsertSchema } from "drizzle-zod";
 import { nanoid } from "nanoid";
 import { z } from "zod";
 import { backups } from "./backups";
+import { environments } from "./environment";
 import { mounts } from "./mount";
-import { projects } from "./project";
 import { server } from "./server";
 import {
 	applicationStatus,
@@ -62,9 +62,10 @@ export const mongo = pgTable("mongo", {
 	createdAt: text("createdAt")
 		.notNull()
 		.$defaultFn(() => new Date().toISOString()),
-	projectId: text("projectId")
+
+	environmentId: text("environmentId")
 		.notNull()
-		.references(() => projects.projectId, { onDelete: "cascade" }),
+		.references(() => environments.environmentId, { onDelete: "cascade" }),
 	serverId: text("serverId").references(() => server.serverId, {
 		onDelete: "cascade",
 	}),
@@ -72,9 +73,9 @@ export const mongo = pgTable("mongo", {
 });
 
 export const mongoRelations = relations(mongo, ({ one, many }) => ({
-	project: one(projects, {
-		fields: [mongo.projectId],
-		references: [projects.projectId],
+	environment: one(environments, {
+		fields: [mongo.environmentId],
+		references: [environments.environmentId],
 	}),
 	backups: many(backups),
 	mounts: many(mounts),
@@ -89,7 +90,12 @@ const createSchema = createInsertSchema(mongo, {
 	createdAt: z.string(),
 	mongoId: z.string(),
 	name: z.string().min(1),
-	databasePassword: z.string(),
+	databasePassword: z
+		.string()
+		.regex(/^[a-zA-Z0-9@#%^&*()_+\-=[\]{}|;:,.<>?~`]*$/, {
+			message:
+				"Password contains invalid characters. Please avoid: $ ! ' \" \\ / and space characters for database compatibility",
+		}),
 	databaseUser: z.string().min(1),
 	dockerImage: z.string().default("mongo:15"),
 	command: z.string().optional(),
@@ -98,7 +104,7 @@ const createSchema = createInsertSchema(mongo, {
 	memoryLimit: z.string().optional(),
 	cpuReservation: z.string().optional(),
 	cpuLimit: z.string().optional(),
-	projectId: z.string(),
+	environmentId: z.string(),
 	applicationStatus: z.enum(["idle", "running", "done", "error"]),
 	externalPort: z.number(),
 	description: z.string().optional(),
@@ -119,7 +125,7 @@ export const apiCreateMongo = createSchema
 		name: true,
 		appName: true,
 		dockerImage: true,
-		projectId: true,
+		environmentId: true,
 		description: true,
 		databaseUser: true,
 		databasePassword: true,

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

@@ -4,8 +4,8 @@ import { createInsertSchema } from "drizzle-zod";
 import { nanoid } from "nanoid";
 import { z } from "zod";
 import { backups } from "./backups";
+import { environments } from "./environment";
 import { mounts } from "./mount";
-import { projects } from "./project";
 import { server } from "./server";
 import {
 	applicationStatus,
@@ -64,18 +64,19 @@ export const mysql = pgTable("mysql", {
 	createdAt: text("createdAt")
 		.notNull()
 		.$defaultFn(() => new Date().toISOString()),
-	projectId: text("projectId")
+
+	environmentId: text("environmentId")
 		.notNull()
-		.references(() => projects.projectId, { onDelete: "cascade" }),
+		.references(() => environments.environmentId, { 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],
+	environment: one(environments, {
+		fields: [mysql.environmentId],
+		references: [environments.environmentId],
 	}),
 	backups: many(backups),
 	mounts: many(mounts),
@@ -92,8 +93,19 @@ const createSchema = createInsertSchema(mysql, {
 	name: z.string().min(1),
 	databaseName: z.string().min(1),
 	databaseUser: z.string().min(1),
-	databasePassword: z.string(),
-	databaseRootPassword: z.string().optional(),
+	databasePassword: z
+		.string()
+		.regex(/^[a-zA-Z0-9@#%^&*()_+\-=[\]{}|;:,.<>?~`]*$/, {
+			message:
+				"Password contains invalid characters. Please avoid: $ ! ' \" \\ / and space characters for database compatibility",
+		}),
+	databaseRootPassword: z
+		.string()
+		.regex(/^[a-zA-Z0-9@#%^&*()_+\-=[\]{}|;:,.<>?~`]*$/, {
+			message:
+				"Password contains invalid characters. Please avoid: $ ! ' \" \\ / and space characters for database compatibility",
+		})
+		.optional(),
 	dockerImage: z.string().default("mysql:8"),
 	command: z.string().optional(),
 	env: z.string().optional(),
@@ -101,7 +113,6 @@ const createSchema = createInsertSchema(mysql, {
 	memoryLimit: z.string().optional(),
 	cpuReservation: z.string().optional(),
 	cpuLimit: z.string().optional(),
-	projectId: z.string(),
 	applicationStatus: z.enum(["idle", "running", "done", "error"]),
 	externalPort: z.number(),
 	description: z.string().optional(),
@@ -121,7 +132,7 @@ export const apiCreateMySql = createSchema
 		name: true,
 		appName: true,
 		dockerImage: true,
-		projectId: true,
+		environmentId: true,
 		description: true,
 		databaseName: true,
 		databaseUser: true,

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

@@ -4,8 +4,8 @@ import { createInsertSchema } from "drizzle-zod";
 import { nanoid } from "nanoid";
 import { z } from "zod";
 import { backups } from "./backups";
+import { environments } from "./environment";
 import { mounts } from "./mount";
-import { projects } from "./project";
 import { server } from "./server";
 import {
 	applicationStatus,
@@ -64,18 +64,19 @@ export const postgres = pgTable("postgres", {
 	createdAt: text("createdAt")
 		.notNull()
 		.$defaultFn(() => new Date().toISOString()),
-	projectId: text("projectId")
+
+	environmentId: text("environmentId")
 		.notNull()
-		.references(() => projects.projectId, { onDelete: "cascade" }),
+		.references(() => environments.environmentId, { 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],
+	environment: one(environments, {
+		fields: [postgres.environmentId],
+		references: [environments.environmentId],
 	}),
 	backups: many(backups),
 	mounts: many(mounts),
@@ -88,7 +89,12 @@ export const postgresRelations = relations(postgres, ({ one, many }) => ({
 const createSchema = createInsertSchema(postgres, {
 	postgresId: z.string(),
 	name: z.string().min(1),
-	databasePassword: z.string(),
+	databasePassword: z
+		.string()
+		.regex(/^[a-zA-Z0-9@#%^&*()_+\-=[\]{}|;:,.<>?~`]*$/, {
+			message:
+				"Password contains invalid characters. Please avoid: $ ! ' \" \\ / and space characters for database compatibility",
+		}),
 	databaseName: z.string().min(1),
 	databaseUser: z.string().min(1),
 	dockerImage: z.string().default("postgres:15"),
@@ -98,7 +104,7 @@ const createSchema = createInsertSchema(postgres, {
 	memoryLimit: z.string().optional(),
 	cpuReservation: z.string().optional(),
 	cpuLimit: z.string().optional(),
-	projectId: z.string(),
+	environmentId: z.string(),
 	applicationStatus: z.enum(["idle", "running", "done", "error"]),
 	externalPort: z.number(),
 	createdAt: z.string(),
@@ -122,7 +128,7 @@ export const apiCreatePostgres = createSchema
 		databaseUser: true,
 		databasePassword: true,
 		dockerImage: true,
-		projectId: true,
+		environmentId: true,
 		description: true,
 		serverId: true,
 	})

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

@@ -4,13 +4,7 @@ import { createInsertSchema } from "drizzle-zod";
 import { nanoid } from "nanoid";
 import { z } from "zod";
 import { organization } from "./account";
-import { applications } from "./application";
-import { compose } from "./compose";
-import { mariadb } from "./mariadb";
-import { mongo } from "./mongo";
-import { mysql } from "./mysql";
-import { postgres } from "./postgres";
-import { redis } from "./redis";
+import { environments } from "./environment";
 
 export const projects = pgTable("project", {
 	projectId: text("projectId")
@@ -30,13 +24,7 @@ export const projects = pgTable("project", {
 });
 
 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),
+	environments: many(environments),
 	organization: one(organization, {
 		fields: [projects.organizationId],
 		references: [organization.id],

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

@@ -3,6 +3,7 @@ import { integer, json, pgTable, text } from "drizzle-orm/pg-core";
 import { createInsertSchema } from "drizzle-zod";
 import { nanoid } from "nanoid";
 import { z } from "zod";
+import { environments } from "./environment";
 import { mounts } from "./mount";
 import { projects } from "./project";
 import { server } from "./server";
@@ -60,18 +61,19 @@ export const redis = pgTable("redis", {
 	labelsSwarm: json("labelsSwarm").$type<LabelsSwarm>(),
 	networkSwarm: json("networkSwarm").$type<NetworkSwarm[]>(),
 	replicas: integer("replicas").default(1).notNull(),
-	projectId: text("projectId")
+
+	environmentId: text("environmentId")
 		.notNull()
-		.references(() => projects.projectId, { onDelete: "cascade" }),
+		.references(() => environments.environmentId, { 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],
+	environment: one(environments, {
+		fields: [redis.environmentId],
+		references: [environments.environmentId],
 	}),
 	mounts: many(mounts),
 	server: one(server, {
@@ -93,7 +95,7 @@ const createSchema = createInsertSchema(redis, {
 	memoryLimit: z.string().optional(),
 	cpuReservation: z.string().optional(),
 	cpuLimit: z.string().optional(),
-	projectId: z.string(),
+	environmentId: z.string(),
 	applicationStatus: z.enum(["idle", "running", "done", "error"]),
 	externalPort: z.number(),
 	description: z.string().optional(),
@@ -114,7 +116,7 @@ export const apiCreateRedis = createSchema
 		appName: true,
 		databasePassword: true,
 		dockerImage: true,
-		projectId: true,
+		environmentId: true,
 		description: true,
 		serverId: true,
 	})

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

@@ -27,7 +27,9 @@ export const rollbacks = pgTable("rollback", {
 		.$defaultFn(() => new Date().toISOString()),
 	fullContext: jsonb("fullContext").$type<
 		Application & {
-			project: Project;
+			environment: {
+				project: Project;
+			};
 			mounts: Mount[];
 			ports: Port[];
 			registry?: Registry | null;

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

@@ -175,6 +175,7 @@ export const apiAssignPermissions = createSchema
 	})
 	.extend({
 		accessedProjects: z.array(z.string()).optional(),
+		accessedEnvironments: z.array(z.string()).optional(),
 		accessedServices: z.array(z.string()).optional(),
 		canCreateProjects: z.boolean().optional(),
 		canCreateServices: z.boolean().optional(),