Reapply "Merge branch 'canary' into kucherenko/canary"

This reverts commit e6cb6454db.

packages/server/src/services/admin.ts

@@ -1,108 +1,56 @@
-import { randomBytes } from "node:crypto";
 import { db } from "@dokploy/server/db";
 import {
-	admins,
-	type apiCreateUserInvitation,
-	auth,
-	users,
+	invitation,
+	member,
+	organization,
+	users_temp,
 } from "@dokploy/server/db/schema";
 import { TRPCError } from "@trpc/server";
-import * as bcrypt from "bcrypt";
 import { eq } from "drizzle-orm";
 import { IS_CLOUD } from "../constants";
 
-export type Admin = typeof admins.$inferSelect;
-export const createInvitation = async (
-	input: typeof apiCreateUserInvitation._type,
-	adminId: string,
-) => {
-	await db.transaction(async (tx) => {
-		const result = await tx
-			.insert(auth)
-			.values({
-				email: input.email.toLowerCase(),
-				rol: "user",
-				password: bcrypt.hashSync("01231203012312", 10),
-			})
-			.returning()
-			.then((res) => res[0]);
-
-		if (!result) {
-			throw new TRPCError({
-				code: "BAD_REQUEST",
-				message: "Error creating the user",
-			});
-		}
-		const expiresIn24Hours = new Date();
-		expiresIn24Hours.setDate(expiresIn24Hours.getDate() + 1);
-		const token = randomBytes(32).toString("hex");
-		await tx
-			.insert(users)
-			.values({
-				adminId: adminId,
-				authId: result.id,
-				token,
-				expirationDate: expiresIn24Hours.toISOString(),
-			})
-			.returning();
+export const findUserById = async (userId: string) => {
+	const user = await db.query.users_temp.findFirst({
+		where: eq(users_temp.id, userId),
+		// with: {
+		// 	account: true,
+		// },
 	});
-};
-
-export const findAdminById = async (adminId: string) => {
-	const admin = await db.query.admins.findFirst({
-		where: eq(admins.adminId, adminId),
-	});
-	if (!admin) {
+	if (!user) {
 		throw new TRPCError({
 			code: "NOT_FOUND",
-			message: "Admin not found",
+			message: "User not found",
 		});
 	}
-	return admin;
+	return user;
 };
 
-export const updateAdmin = async (
-	authId: string,
-	adminData: Partial<Admin>,
-) => {
-	const admin = await db
-		.update(admins)
-		.set({
-			...adminData,
-		})
-		.where(eq(admins.authId, authId))
-		.returning()
-		.then((res) => res[0]);
-
-	return admin;
+export const findOrganizationById = async (organizationId: string) => {
+	const organizationResult = await db.query.organization.findFirst({
+		where: eq(organization.id, organizationId),
+	});
+	return organizationResult;
 };
 
 export const isAdminPresent = async () => {
-	const admin = await db.query.admins.findFirst();
+	const admin = await db.query.member.findFirst({
+		where: eq(member.role, "owner"),
+	});
+
 	if (!admin) {
 		return false;
 	}
 	return true;
 };
 
-export const findAdminByAuthId = async (authId: string) => {
-	const admin = await db.query.admins.findFirst({
-		where: eq(admins.authId, authId),
+export const findAdmin = async () => {
+	const admin = await db.query.member.findFirst({
+		where: eq(member.role, "owner"),
 		with: {
-			users: true,
+			user: true,
 		},
 	});
-	if (!admin) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Admin not found",
-		});
-	}
-	return admin;
-};
 
-export const findAdmin = async () => {
-	const admin = await db.query.admins.findFirst({});
 	if (!admin) {
 		throw new TRPCError({
 			code: "NOT_FOUND",
@@ -113,14 +61,15 @@ export const findAdmin = async () => {
 };
 
 export const getUserByToken = async (token: string) => {
-	const user = await db.query.users.findFirst({
-		where: eq(users.token, token),
-		with: {
-			auth: {
-				columns: {
-					password: false,
-				},
-			},
+	const user = await db.query.invitation.findFirst({
+		where: eq(invitation.id, token),
+		columns: {
+			id: true,
+			email: true,
+			status: true,
+			expiresAt: true,
+			role: true,
+			inviterId: true,
 		},
 	});
 
@@ -130,34 +79,23 @@ export const getUserByToken = async (token: string) => {
 			message: "Invitation not found",
 		});
 	}
+
+	const userAlreadyExists = await db.query.users_temp.findFirst({
+		where: eq(users_temp.email, user?.email || ""),
+	});
+
+	const { expiresAt, ...rest } = user;
 	return {
-		...user,
-		isExpired: user.isRegistered,
+		...rest,
+		isExpired: user.expiresAt < new Date(),
+		userAlreadyExists: !!userAlreadyExists,
 	};
 };
 
-export const removeUserByAuthId = async (authId: string) => {
+export const removeUserById = async (userId: string) => {
 	await db
-		.delete(auth)
-		.where(eq(auth.id, authId))
-		.returning()
-		.then((res) => res[0]);
-};
-
-export const removeAdminByAuthId = async (authId: string) => {
-	const admin = await findAdminByAuthId(authId);
-	if (!admin) return null;
-
-	// First delete all associated users
-	const users = admin.users;
-
-	for (const user of users) {
-		await removeUserByAuthId(user.authId);
-	}
-	// Then delete the auth record which will cascade delete the admin
-	return await db
-		.delete(auth)
-		.where(eq(auth.id, authId))
+		.delete(users_temp)
+		.where(eq(users_temp.id, userId))
 		.returning()
 		.then((res) => res[0]);
 };
@@ -168,8 +106,8 @@ export const getDokployUrl = async () => {
 	}
 	const admin = await findAdmin();
 
-	if (admin.host) {
-		return `https://${admin.host}`;
+	if (admin.user.host) {
+		return `https://${admin.user.host}`;
 	}
-	return `http://${admin.serverIp}:${process.env.PORT}`;
+	return `http://${admin.user.serverIp}:${process.env.PORT}`;
 };