Merged v2.4.0

src/lib/database/applications.ts

@@ -14,7 +14,13 @@ import type {
 } from '@prisma/client';
 
 export async function listApplications(teamId: string): Promise<Application[]> {
-	return await prisma.application.findMany({ where: { teams: { some: { id: teamId } } } });
+	if (teamId === '0') {
+		return await prisma.application.findMany({ include: { teams: true } });
+	}
+	return await prisma.application.findMany({
+		where: { teams: { some: { id: teamId } } },
+		include: { teams: true }
+	});
 }
 
 export async function newApplication({
@@ -133,13 +139,7 @@ export async function getApplicationWebhook({
 	}
 }
 
-export async function getApplication({
-	id,
-	teamId
-}: {
-	id: string;
-	teamId: string;
-}): Promise<
+export async function getApplication({ id, teamId }: { id: string; teamId: string }): Promise<
 	Application & {
 		destinationDocker: DestinationDocker;
 		settings: ApplicationSettings;
@@ -148,16 +148,30 @@ export async function getApplication({
 		persistentStorage: ApplicationPersistentStorage[];
 	}
 > {
-	const body = await prisma.application.findFirst({
-		where: { id, teams: { some: { id: teamId } } },
-		include: {
-			destinationDocker: true,
-			settings: true,
-			gitSource: { include: { githubApp: true, gitlabApp: true } },
-			secrets: true,
-			persistentStorage: true
-		}
-	});
+	let body;
+	if (teamId === '0') {
+		body = await prisma.application.findFirst({
+			where: { id },
+			include: {
+				destinationDocker: true,
+				settings: true,
+				gitSource: { include: { githubApp: true, gitlabApp: true } },
+				secrets: true,
+				persistentStorage: true
+			}
+		});
+	} else {
+		body = await prisma.application.findFirst({
+			where: { id, teams: { some: { id: teamId } } },
+			include: {
+				destinationDocker: true,
+				settings: true,
+				gitSource: { include: { githubApp: true, gitlabApp: true } },
+				secrets: true,
+				persistentStorage: true
+			}
+		});
+	}
 
 	if (body?.gitSource?.githubApp?.clientSecret) {
 		body.gitSource.githubApp.clientSecret = decrypt(body.gitSource.githubApp.clientSecret);

src/lib/database/common.ts

@@ -1,5 +1,9 @@
 import { dev } from '$app/env';
 import { sentry } from '$lib/common';
+import {
+	supportedDatabaseTypesAndVersions,
+	supportedServiceTypesAndVersions
+} from '$lib/components/common';
 import * as Prisma from '@prisma/client';
 import { default as ProdPrisma } from '@prisma/client';
 import type { Database, DatabaseSettings } from '@prisma/client';
@@ -87,134 +91,6 @@ export async function generateSshKeyPair(): Promise<{ publicKey: string; private
 	});
 }
 
-export const supportedDatabaseTypesAndVersions = [
-	{
-		name: 'mongodb',
-		fancyName: 'MongoDB',
-		baseImage: 'bitnami/mongodb',
-		versions: ['5.0.5', '4.4.11', '4.2.18', '4.0.27']
-	},
-	{ name: 'mysql', fancyName: 'MySQL', baseImage: 'bitnami/mysql', versions: ['8.0.27', '5.7.36'] },
-	{
-		name: 'postgresql',
-		fancyName: 'PostgreSQL',
-		baseImage: 'bitnami/postgresql',
-		versions: ['14.1.0', '13.5.0', '12.9.0', '11.14.0', '10.19.0', '9.6.24']
-	},
-	{
-		name: 'redis',
-		fancyName: 'Redis',
-		baseImage: 'bitnami/redis',
-		versions: ['6.2.6', '6.0.16', '5.0.14']
-	},
-	{ name: 'couchdb', fancyName: 'CouchDB', baseImage: 'bitnami/couchdb', versions: ['3.2.1'] }
-];
-export const supportedServiceTypesAndVersions = [
-	{
-		name: 'plausibleanalytics',
-		fancyName: 'Plausible Analytics',
-		baseImage: 'plausible/analytics',
-		images: ['bitnami/postgresql:13.2.0', 'yandex/clickhouse-server:21.3.2.5'],
-		versions: ['latest'],
-		ports: {
-			main: 8000
-		}
-	},
-	{
-		name: 'nocodb',
-		fancyName: 'NocoDB',
-		baseImage: 'nocodb/nocodb',
-		versions: ['latest'],
-		ports: {
-			main: 8080
-		}
-	},
-	{
-		name: 'minio',
-		fancyName: 'MinIO',
-		baseImage: 'minio/minio',
-		versions: ['latest'],
-		ports: {
-			main: 9001
-		}
-	},
-	{
-		name: 'vscodeserver',
-		fancyName: 'VSCode Server',
-		baseImage: 'codercom/code-server',
-		versions: ['latest'],
-		ports: {
-			main: 8080
-		}
-	},
-	{
-		name: 'wordpress',
-		fancyName: 'Wordpress',
-		baseImage: 'wordpress',
-		images: ['bitnami/mysql:5.7'],
-		versions: ['latest', 'php8.1', 'php8.0', 'php7.4', 'php7.3'],
-		ports: {
-			main: 80
-		}
-	},
-	{
-		name: 'vaultwarden',
-		fancyName: 'Vaultwarden',
-		baseImage: 'vaultwarden/server',
-		versions: ['latest'],
-		ports: {
-			main: 80
-		}
-	},
-	{
-		name: 'languagetool',
-		fancyName: 'LanguageTool',
-		baseImage: 'silviof/docker-languagetool',
-		versions: ['latest'],
-		ports: {
-			main: 8010
-		}
-	},
-	{
-		name: 'n8n',
-		fancyName: 'n8n',
-		baseImage: 'n8nio/n8n',
-		versions: ['latest'],
-		ports: {
-			main: 5678
-		}
-	},
-	{
-		name: 'uptimekuma',
-		fancyName: 'Uptime Kuma',
-		baseImage: 'louislam/uptime-kuma',
-		versions: ['latest'],
-		ports: {
-			main: 3001
-		}
-	},
-	{
-		name: 'ghost',
-		fancyName: 'Ghost',
-		baseImage: 'bitnami/ghost',
-		images: ['bitnami/mariadb'],
-		versions: ['latest'],
-		ports: {
-			main: 2368
-		}
-	},
-	{
-		name: 'meilisearch',
-		fancyName: 'Meilisearch',
-		baseImage: 'getmeili/meilisearch',
-		images: [],
-		versions: ['latest'],
-		ports: {
-			main: 7700
-		}
-	}
-];
-
 export function getVersions(type: string): string[] {
 	const found = supportedDatabaseTypesAndVersions.find((t) => t.name === type);
 	if (found) {

src/lib/database/databases.ts

@@ -6,7 +6,14 @@ import { asyncExecShell, getEngine, removeContainer } from '$lib/common';
 import type { Database, DatabaseSettings, DestinationDocker } from '@prisma/client';
 
 export async function listDatabases(teamId: string): Promise<Database[]> {
-	return await prisma.database.findMany({ where: { teams: { some: { id: teamId } } } });
+	if (teamId === '0') {
+		return await prisma.database.findMany({ include: { teams: true } });
+	} else {
+		return await prisma.database.findMany({
+			where: { teams: { some: { id: teamId } } },
+			include: { teams: true }
+		});
+	}
 }
 
 export async function newDatabase({
@@ -43,11 +50,18 @@ export async function getDatabase({
 	id: string;
 	teamId: string;
 }): Promise<Database & { destinationDocker: DestinationDocker; settings: DatabaseSettings }> {
-	const body = await prisma.database.findFirst({
-		where: { id, teams: { some: { id: teamId } } },
-		include: { destinationDocker: true, settings: true }
-	});
-
+	let body;
+	if (teamId === '0') {
+		body = await prisma.database.findFirst({
+			where: { id },
+			include: { destinationDocker: true, settings: true }
+		});
+	} else {
+		body = await prisma.database.findFirst({
+			where: { id, teams: { some: { id: teamId } } },
+			include: { destinationDocker: true, settings: true }
+		});
+	}
 	if (body.dbUserPassword) body.dbUserPassword = decrypt(body.dbUserPassword);
 	if (body.rootUserPassword) body.rootUserPassword = decrypt(body.rootUserPassword);
 

src/lib/database/destinations.ts

@@ -1,5 +1,4 @@
 import { asyncExecShell, getEngine } from '$lib/common';
-import { decrypt } from '$lib/crypto';
 import { dockerInstance } from '$lib/docker';
 import { startCoolifyProxy } from '$lib/haproxy';
 import { getDatabaseImage } from '.';
@@ -18,7 +17,13 @@ type FindDestinationFromTeam = {
 };
 
 export async function listDestinations(teamId: string): Promise<DestinationDocker[]> {
-	return await prisma.destinationDocker.findMany({ where: { teams: { some: { id: teamId } } } });
+	if (teamId === '0') {
+		return await prisma.destinationDocker.findMany({ include: { teams: true } });
+	}
+	return await prisma.destinationDocker.findMany({
+		where: { teams: { some: { id: teamId } } },
+		include: { teams: true }
+	});
 }
 
 export async function configureDestinationForService({
@@ -146,12 +151,17 @@ export async function getDestination({
 	id,
 	teamId
 }: FindDestinationFromTeam): Promise<DestinationDocker & { sshPrivateKey?: string }> {
-	const destination = (await prisma.destinationDocker.findFirst({
-		where: { id, teams: { some: { id: teamId } } }
-	})) as DestinationDocker & { sshPrivateKey?: string };
-	if (destination.remoteEngine) {
-		destination.sshPrivateKey = decrypt(destination.sshPrivateKey);
+	let destination;
+	if (teamId === '0') {
+		destination = await prisma.destinationDocker.findFirst({
+			where: { id }
+		});
+	} else {
+		destination = await prisma.destinationDocker.findFirst({
+			where: { id, teams: { some: { id: teamId } } }
+		});
 	}
+
 	return destination;
 }
 export async function getDestinationByApplicationId({

src/lib/database/gitSources.ts

@@ -5,9 +5,14 @@ import type { GithubApp, GitlabApp, GitSource, Prisma, Application } from '@pris
 export async function listSources(
 	teamId: string | Prisma.StringFilter
 ): Promise<(GitSource & { githubApp?: GithubApp; gitlabApp?: GitlabApp })[]> {
+	if (teamId === '0') {
+		return await prisma.gitSource.findMany({
+			include: { githubApp: true, gitlabApp: true, teams: true }
+		});
+	}
 	return await prisma.gitSource.findMany({
 		where: { teams: { some: { id: teamId } } },
-		include: { githubApp: true, gitlabApp: true }
+		include: { githubApp: true, gitlabApp: true, teams: true }
 	});
 }
 
@@ -54,10 +59,18 @@ export async function getSource({
 	id: string;
 	teamId: string;
 }): Promise<GitSource & { githubApp: GithubApp; gitlabApp: GitlabApp }> {
-	const body = await prisma.gitSource.findFirst({
-		where: { id, teams: { some: { id: teamId } } },
-		include: { githubApp: true, gitlabApp: true }
-	});
+	let body;
+	if (teamId === '0') {
+		body = await prisma.gitSource.findFirst({
+			where: { id },
+			include: { githubApp: true, gitlabApp: true }
+		});
+	} else {
+		body = await prisma.gitSource.findFirst({
+			where: { id, teams: { some: { id: teamId } } },
+			include: { githubApp: true, gitlabApp: true }
+		});
+	}
 	if (body?.githubApp?.clientSecret)
 		body.githubApp.clientSecret = decrypt(body.githubApp.clientSecret);
 	if (body?.githubApp?.webhookSecret)

src/lib/database/services.ts

@@ -5,7 +5,14 @@ import { generatePassword } from '.';
 import { prisma } from './common';
 
 export async function listServices(teamId: string): Promise<Service[]> {
-	return await prisma.service.findMany({ where: { teams: { some: { id: teamId } } } });
+	if (teamId === '0') {
+		return await prisma.service.findMany({ include: { teams: true } });
+	} else {
+		return await prisma.service.findMany({
+			where: { teams: { some: { id: teamId } } },
+			include: { teams: true }
+		});
+	}
 }
 
 export async function newService({
@@ -19,19 +26,28 @@ export async function newService({
 }
 
 export async function getService({ id, teamId }: { id: string; teamId: string }): Promise<Service> {
-	const body = await prisma.service.findFirst({
-		where: { id, teams: { some: { id: teamId } } },
-		include: {
-			destinationDocker: true,
-			plausibleAnalytics: true,
-			minio: true,
-			vscodeserver: true,
-			wordpress: true,
-			ghost: true,
-			serviceSecret: true,
-			meiliSearch: true
-		}
-	});
+	let body;
+	const include = {
+		destinationDocker: true,
+		plausibleAnalytics: true,
+		minio: true,
+		vscodeserver: true,
+		wordpress: true,
+		ghost: true,
+		serviceSecret: true,
+		meiliSearch: true
+	};
+	if (teamId === '0') {
+		body = await prisma.service.findFirst({
+			where: { id },
+			include
+		});
+	} else {
+		body = await prisma.service.findFirst({
+			where: { id, teams: { some: { id: teamId } } },
+			include
+		});
+	}
 
 	if (body.plausibleAnalytics?.postgresqlPassword)
 		body.plausibleAnalytics.postgresqlPassword = decrypt(
@@ -65,8 +81,12 @@ export async function getService({ id, teamId }: { id: string; teamId: string })
 			return s;
 		});
 	}
+	if (body.wordpress?.ftpPassword) {
+		body.wordpress.ftpPassword = decrypt(body.wordpress.ftpPassword);
+	}
+	const settings = await prisma.setting.findFirst();
 
-	return { ...body };
+	return { ...body, settings };
 }
 
 export async function configureServiceType({
@@ -191,6 +211,7 @@ export async function configureServiceType({
 		});
 	}
 }
+
 export async function setServiceVersion({
 	id,
 	version
@@ -233,6 +254,7 @@ export async function updatePlausibleAnalyticsService({
 	await prisma.plausibleAnalytics.update({ where: { serviceId: id }, data: { email, username } });
 	await prisma.service.update({ where: { id }, data: { name, fqdn } });
 }
+
 export async function updateService({
 	id,
 	fqdn,
@@ -244,6 +266,7 @@ export async function updateService({
 }): Promise<Service> {
 	return await prisma.service.update({ where: { id }, data: { fqdn, name } });
 }
+
 export async function updateLanguageToolService({
 	id,
 	fqdn,
@@ -255,6 +278,7 @@ export async function updateLanguageToolService({
 }): Promise<Service> {
 	return await prisma.service.update({ where: { id }, data: { fqdn, name } });
 }
+
 export async function updateMeiliSearchService({
 	id,
 	fqdn,
@@ -266,6 +290,7 @@ export async function updateMeiliSearchService({
 }): Promise<Service> {
 	return await prisma.service.update({ where: { id }, data: { fqdn, name } });
 }
+
 export async function updateVaultWardenService({
 	id,
 	fqdn,
@@ -277,6 +302,7 @@ export async function updateVaultWardenService({
 }): Promise<Service> {
 	return await prisma.service.update({ where: { id }, data: { fqdn, name } });
 }
+
 export async function updateVsCodeServer({
 	id,
 	fqdn,
@@ -288,6 +314,7 @@ export async function updateVsCodeServer({
 }): Promise<Service> {
 	return await prisma.service.update({ where: { id }, data: { fqdn, name } });
 }
+
 export async function updateWordpress({
 	id,
 	fqdn,
@@ -306,6 +333,7 @@ export async function updateWordpress({
 		data: { fqdn, name, wordpress: { update: { mysqlDatabase, extraConfig } } }
 	});
 }
+
 export async function updateMinioService({
 	id,
 	publicPort
@@ -315,6 +343,7 @@ export async function updateMinioService({
 }): Promise<Minio> {
 	return await prisma.minio.update({ where: { serviceId: id }, data: { publicPort } });
 }
+
 export async function updateGhostService({
 	id,
 	fqdn,