refactor: remove old references

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

@@ -1,210 +0,0 @@
-import { relations } from "drizzle-orm";
-import {
-	boolean,
-	integer,
-	json,
-	jsonb,
-	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 { certificates } from "./certificate";
-import { registry } from "./registry";
-import { certificateType } from "./shared";
-import { sshKeys } from "./ssh-key";
-import { users } from "./user";
-
-export const admins = pgTable("admin", {
-	adminId: text("adminId")
-		.notNull()
-		.primaryKey()
-		.$defaultFn(() => nanoid()),
-	serverIp: text("serverIp"),
-	certificateType: certificateType("certificateType").notNull().default("none"),
-	host: text("host"),
-	letsEncryptEmail: text("letsEncryptEmail"),
-	sshPrivateKey: text("sshPrivateKey"),
-	enableDockerCleanup: boolean("enableDockerCleanup").notNull().default(false),
-	enableLogRotation: boolean("enableLogRotation").notNull().default(false),
-	authId: text("authId")
-		.notNull()
-		.references(() => auth.id, { onDelete: "cascade" }),
-	createdAt: text("createdAt")
-		.notNull()
-		.$defaultFn(() => new Date().toISOString()),
-	stripeCustomerId: text("stripeCustomerId"),
-	stripeSubscriptionId: text("stripeSubscriptionId"),
-	serversQuantity: integer("serversQuantity").notNull().default(0),
-
-	// Metrics
-	enablePaidFeatures: boolean("enablePaidFeatures").notNull().default(false),
-	metricsConfig: jsonb("metricsConfig")
-		.$type<{
-			server: {
-				type: "Dokploy" | "Remote";
-				refreshRate: number;
-				port: number;
-				token: string;
-				urlCallback: string;
-				retentionDays: number;
-				cronJob: string;
-				thresholds: {
-					cpu: number;
-					memory: number;
-				};
-			};
-			containers: {
-				refreshRate: number;
-				services: {
-					include: string[];
-					exclude: string[];
-				};
-			};
-		}>()
-		.notNull()
-		.default({
-			server: {
-				type: "Dokploy",
-				refreshRate: 60,
-				port: 4500,
-				token: "",
-				retentionDays: 2,
-				cronJob: "",
-				urlCallback: "",
-				thresholds: {
-					cpu: 0,
-					memory: 0,
-				},
-			},
-			containers: {
-				refreshRate: 60,
-				services: {
-					include: [],
-					exclude: [],
-				},
-			},
-		}),
-	cleanupCacheApplications: boolean("cleanupCacheApplications")
-		.notNull()
-		.default(false),
-	cleanupCacheOnPreviews: boolean("cleanupCacheOnPreviews")
-		.notNull()
-		.default(false),
-	cleanupCacheOnCompose: boolean("cleanupCacheOnCompose")
-		.notNull()
-		.default(false),
-});
-
-export const adminsRelations = relations(admins, ({ one, many }) => ({
-	auth: one(auth, {
-		fields: [admins.authId],
-		references: [auth.id],
-	}),
-	users: many(users),
-	registry: many(registry),
-	sshKeys: many(sshKeys),
-	certificates: many(certificates),
-}));
-
-const createSchema = createInsertSchema(admins, {
-	adminId: z.string(),
-	enableDockerCleanup: z.boolean().optional(),
-	sshPrivateKey: z.string().optional(),
-	certificateType: z.enum(["letsencrypt", "none"]).default("none"),
-	serverIp: z.string().optional(),
-	letsEncryptEmail: z.string().optional(),
-});
-
-export const apiUpdateAdmin = createSchema.partial();
-
-export const apiSaveSSHKey = createSchema
-	.pick({
-		sshPrivateKey: true,
-	})
-	.required();
-
-export const apiAssignDomain = createSchema
-	.pick({
-		host: true,
-		certificateType: true,
-		letsEncryptEmail: true,
-	})
-	.required()
-	.partial({
-		letsEncryptEmail: true,
-	});
-
-export const apiUpdateDockerCleanup = createSchema
-	.pick({
-		enableDockerCleanup: true,
-	})
-	.required()
-	.extend({
-		serverId: z.string().optional(),
-	});
-
-export const apiTraefikConfig = z.object({
-	traefikConfig: z.string().min(1),
-});
-
-export const apiModifyTraefikConfig = z.object({
-	path: z.string().min(1),
-	traefikConfig: z.string().min(1),
-	serverId: z.string().optional(),
-});
-export const apiReadTraefikConfig = z.object({
-	path: z.string().min(1),
-	serverId: z.string().optional(),
-});
-
-export const apiEnableDashboard = z.object({
-	enableDashboard: z.boolean().optional(),
-	serverId: z.string().optional(),
-});
-
-export const apiServerSchema = z
-	.object({
-		serverId: z.string().optional(),
-	})
-	.optional();
-
-export const apiReadStatsLogs = z.object({
-	page: z
-		.object({
-			pageIndex: z.number(),
-			pageSize: z.number(),
-		})
-		.optional(),
-	status: z.string().array().optional(),
-	search: z.string().optional(),
-	sort: z.object({ id: z.string(), desc: z.boolean() }).optional(),
-});
-
-export const apiUpdateWebServerMonitoring = z.object({
-	metricsConfig: z
-		.object({
-			server: z.object({
-				refreshRate: z.number().min(2),
-				port: z.number().min(1),
-				token: z.string(),
-				urlCallback: z.string().url(),
-				retentionDays: z.number().min(1),
-				cronJob: z.string().min(1),
-				thresholds: z.object({
-					cpu: z.number().min(0),
-					memory: z.number().min(0),
-				}),
-			}),
-			containers: z.object({
-				refreshRate: z.number().min(2),
-				services: z.object({
-					include: z.array(z.string()).optional(),
-					exclude: z.array(z.string()).optional(),
-				}),
-			}),
-		})
-		.required(),
-});

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

@@ -1,130 +0,0 @@
-import { getRandomValues } from "node:crypto";
-import { relations } from "drizzle-orm";
-import { boolean, pgEnum, pgTable, text } from "drizzle-orm/pg-core";
-import { createInsertSchema } from "drizzle-zod";
-import { nanoid } from "nanoid";
-import { z } from "zod";
-// import { admins } from "./admin";
-import { users } from "./user";
-
-const randomImages = [
-	"/avatars/avatar-1.png",
-	"/avatars/avatar-2.png",
-	"/avatars/avatar-3.png",
-	"/avatars/avatar-4.png",
-	"/avatars/avatar-5.png",
-	"/avatars/avatar-6.png",
-	"/avatars/avatar-7.png",
-	"/avatars/avatar-8.png",
-	"/avatars/avatar-9.png",
-	"/avatars/avatar-10.png",
-	"/avatars/avatar-11.png",
-	"/avatars/avatar-12.png",
-];
-
-const generateRandomImage = () => {
-	return (
-		randomImages[
-			// @ts-ignore
-			getRandomValues(new Uint32Array(1))[0] % randomImages.length
-		] || "/avatars/avatar-1.png"
-	);
-};
-export type DatabaseUser = typeof auth.$inferSelect;
-export const roles = pgEnum("Roles", ["admin", "user"]);
-
-export const auth = pgTable("auth", {
-	id: text("id")
-		.notNull()
-		.primaryKey()
-		.$defaultFn(() => nanoid()),
-	email: text("email").notNull().unique(),
-	password: text("password").notNull(),
-	rol: roles("rol").notNull(),
-	image: text("image").$defaultFn(() => generateRandomImage()),
-	secret: text("secret"),
-	token: text("token"),
-	is2FAEnabled: boolean("is2FAEnabled").notNull().default(false),
-	createdAt: text("createdAt")
-		.notNull()
-		.$defaultFn(() => new Date().toISOString()),
-	resetPasswordToken: text("resetPasswordToken"),
-	resetPasswordExpiresAt: text("resetPasswordExpiresAt"),
-	confirmationToken: text("confirmationToken"),
-	confirmationExpiresAt: text("confirmationExpiresAt"),
-});
-
-export const authRelations = relations(auth, ({ many }) => ({
-	// admins: many(admins),
-	users: many(users),
-}));
-const createSchema = createInsertSchema(auth, {
-	email: z.string().email(),
-	password: z.string().min(8),
-	rol: z.enum(["admin", "user"]),
-	image: z.string().optional(),
-});
-
-export const apiCreateAdmin = createSchema.pick({
-	email: true,
-	password: true,
-});
-
-export const apiCreateUser = createSchema
-	.pick({
-		password: true,
-		id: true,
-		token: true,
-	})
-	.required()
-	.extend({
-		token: z.string().min(1),
-	});
-
-export const apiLogin = createSchema
-	.pick({
-		email: true,
-		password: true,
-	})
-	.required();
-
-export const apiUpdateAuth = createSchema.partial().extend({
-	email: z.string().nullable(),
-	password: z.string().nullable(),
-	image: z.string().optional(),
-	currentPassword: z.string().nullable(),
-});
-
-export const apiUpdateAuthByAdmin = createSchema.partial().extend({
-	email: z.string().nullable(),
-	password: z.string().nullable(),
-	image: z.string().optional(),
-	id: z.string().min(1),
-});
-
-export const apiFindOneAuth = createSchema
-	.pick({
-		id: true,
-	})
-	.required();
-
-export const apiVerify2FA = createSchema
-	.extend({
-		pin: z.string().min(6),
-		secret: z.string().min(1),
-	})
-	.pick({
-		pin: true,
-		secret: true,
-	})
-	.required();
-
-export const apiVerifyLogin2FA = createSchema
-	.extend({
-		pin: z.string().min(6),
-	})
-	.pick({
-		pin: true,
-		id: true,
-	})
-	.required();

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

@@ -4,10 +4,7 @@ import { createInsertSchema } from "drizzle-zod";
 import { nanoid } from "nanoid";
 import { z } from "zod";
 import { organization } from "./account";
-import { admins } from "./admin";
 import { server } from "./server";
-import { users_temp } from "./user";
-// import { user } from "./user";
 import { generateAppName } from "./utils";
 
 export const certificates = pgTable("certificate", {

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

@@ -1,4 +1,4 @@
-import { is, relations } from "drizzle-orm";
+import { relations } from "drizzle-orm";
 import {
 	type AnyPgColumn,
 	boolean,

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

@@ -4,10 +4,7 @@ import { createInsertSchema } from "drizzle-zod";
 import { nanoid } from "nanoid";
 import { z } from "zod";
 import { organization } from "./account";
-import { admins } from "./admin";
 import { backups } from "./backups";
-import { users_temp } from "./user";
-// import { user } from "./user";
 
 export const destinations = pgTable("destination", {
 	destinationId: text("destinationId")
@@ -20,7 +17,6 @@ export const destinations = pgTable("destination", {
 	secretAccessKey: text("secretAccessKey").notNull(),
 	bucket: text("bucket").notNull(),
 	region: text("region").notNull(),
-	//   maybe it can be null
 	endpoint: text("endpoint").notNull(),
 	organizationId: text("organizationId")
 		.notNull()
@@ -35,10 +31,6 @@ export const destinationsRelations = relations(
 			fields: [destinations.organizationId],
 			references: [organization.id],
 		}),
-		// user: one(user, {
-		// 	fields: [destinations.userId],
-		// 	references: [user.id],
-		// }),
 	}),
 );
 

packages/server/src/db/schema/git-provider.ts

@@ -4,12 +4,9 @@ import { createInsertSchema } from "drizzle-zod";
 import { nanoid } from "nanoid";
 import { z } from "zod";
 import { organization } from "./account";
-import { admins } from "./admin";
 import { bitbucket } from "./bitbucket";
 import { github } from "./github";
 import { gitlab } from "./gitlab";
-import { users_temp } from "./user";
-// import { user } from "./user";
 
 export const gitProviderType = pgEnum("gitProviderType", [
 	"github",

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

@@ -1,8 +1,6 @@
 export * from "./application";
 export * from "./postgres";
 export * from "./user";
-export * from "./admin";
-export * from "./auth";
 export * from "./project";
 export * from "./domain";
 export * from "./mariadb";

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

@@ -4,8 +4,6 @@ import { createInsertSchema } from "drizzle-zod";
 import { nanoid } from "nanoid";
 import { z } from "zod";
 import { organization } from "./account";
-import { users_temp } from "./user";
-// import { user } from "./user";
 
 export const notificationType = pgEnum("notificationType", [
 	"slack",

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

@@ -1,12 +1,9 @@
 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 { organization } from "./account";
-import { admins } from "./admin";
-// import { admins } from "./admin";
 import { applications } from "./application";
 import { compose } from "./compose";
 import { mariadb } from "./mariadb";
@@ -14,7 +11,6 @@ import { mongo } from "./mongo";
 import { mysql } from "./mysql";
 import { postgres } from "./postgres";
 import { redis } from "./redis";
-import { users, users_temp } from "./user";
 
 export const projects = pgTable("project", {
 	projectId: text("projectId")

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

@@ -4,10 +4,7 @@ import { createInsertSchema } from "drizzle-zod";
 import { nanoid } from "nanoid";
 import { z } from "zod";
 import { organization } from "./account";
-import { admins } from "./admin";
 import { applications } from "./application";
-import { users_temp } from "./user";
-// import { user } from "./user";
 /**
  * This is an example of how to use the multi-project schema feature of Drizzle ORM. Use the same
  * database instance for multiple projects.
@@ -36,10 +33,6 @@ export const registry = pgTable("registry", {
 });
 
 export const registryRelations = relations(registry, ({ one, many }) => ({
-	// user: one(user, {
-	// 	fields: [registry.userId],
-	// 	references: [user.id],
-	// }),
 	applications: many(applications),
 }));
 

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

@@ -10,9 +10,7 @@ import {
 import { createInsertSchema } from "drizzle-zod";
 import { nanoid } from "nanoid";
 import { z } from "zod";
-
 import { organization } from "./account";
-import { admins } from "./admin";
 import { applications } from "./application";
 import { certificates } from "./certificate";
 import { compose } from "./compose";
@@ -23,8 +21,6 @@ import { mysql } from "./mysql";
 import { postgres } from "./postgres";
 import { redis } from "./redis";
 import { sshKeys } from "./ssh-key";
-import { users_temp } from "./user";
-// import { user } from "./user";
 import { generateAppName } from "./utils";
 
 export const serverStatus = pgEnum("serverStatus", ["active", "inactive"]);
@@ -101,10 +97,6 @@ export const server = pgTable("server", {
 });
 
 export const serverRelations = relations(server, ({ one, many }) => ({
-	// user: one(user, {
-	// 	fields: [server.userId],
-	// 	references: [user.id],
-	// }),
 	deployments: many(deployments),
 	sshKey: one(sshKeys, {
 		fields: [server.sshKeyId],

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

@@ -1,6 +1,4 @@
-import { sql } from "drizzle-orm";
 import { pgTable, text, timestamp } from "drizzle-orm/pg-core";
-import { auth } from "./auth";
 import { users_temp } from "./user";
 
 // OLD TABLE
@@ -18,14 +16,3 @@ export const session = pgTable("session_temp", {
 	impersonatedBy: text("impersonated_by"),
 	activeOrganizationId: text("active_organization_id"),
 });
-
-export const sessionTable = pgTable("session", {
-	id: text("id").primaryKey(),
-	userId: text("user_id")
-		.notNull()
-		.references(() => auth.id, { onDelete: "cascade" }),
-	expiresAt: timestamp("expires_at", {
-		withTimezone: true,
-		mode: "date",
-	}).notNull(),
-});

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

@@ -1,27 +0,0 @@
-import { pgTable, text } from "drizzle-orm/pg-core";
-import { createInsertSchema } from "drizzle-zod";
-import { nanoid } from "nanoid";
-import { z } from "zod";
-
-export const source = pgTable("project", {
-	projectId: text("projectId")
-		.notNull()
-		.primaryKey()
-		.$defaultFn(() => nanoid()),
-	name: text("name").notNull(),
-	description: text("description"),
-	createdAt: text("createdAt")
-		.notNull()
-		.$defaultFn(() => new Date().toISOString()),
-});
-
-const createSchema = createInsertSchema(source, {
-	name: z.string().min(1),
-	description: z.string(),
-	projectId: z.string(),
-});
-
-export const apiCreate = createSchema.pick({
-	name: true,
-	description: true,
-});

packages/server/src/db/schema/ssh-key.ts

@@ -4,12 +4,9 @@ import { createInsertSchema } from "drizzle-zod";
 import { nanoid } from "nanoid";
 import { sshKeyCreate, sshKeyType } from "../validations";
 import { organization } from "./account";
-import { admins } from "./admin";
 import { applications } from "./application";
 import { compose } from "./compose";
 import { server } from "./server";
-import { users_temp } from "./user";
-// import { user } from "./user";
 
 export const sshKeys = pgTable("ssh-key", {
 	sshKeyId: text("sshKeyId")

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

@@ -11,8 +11,6 @@ import { createInsertSchema } from "drizzle-zod";
 import { nanoid } from "nanoid";
 import { z } from "zod";
 import { account, organization } from "./account";
-import { admins } from "./admin";
-import { auth } from "./auth";
 import { projects } from "./project";
 import { certificateType } from "./shared";
 /**
@@ -24,50 +22,6 @@ import { certificateType } from "./shared";
 
 // OLD TABLE
 
-export const users = pgTable("user", {
-	userId: text("userId")
-		.notNull()
-		.primaryKey()
-		.$defaultFn(() => nanoid()),
-
-	token: text("token").notNull(),
-	isRegistered: boolean("isRegistered").notNull().default(false),
-	expirationDate: timestamp("expirationDate", {
-		precision: 3,
-		mode: "string",
-	}).notNull(),
-	createdAt: text("createdAt")
-		.notNull()
-		.$defaultFn(() => new Date().toISOString()),
-	canCreateProjects: boolean("canCreateProjects").notNull().default(false),
-	canAccessToSSHKeys: boolean("canAccessToSSHKeys").notNull().default(false),
-	canCreateServices: boolean("canCreateServices").notNull().default(false),
-	canDeleteProjects: boolean("canDeleteProjects").notNull().default(false),
-	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),
-	accessedProjects: text("accesedProjects")
-		.array()
-		.notNull()
-		.default(sql`ARRAY[]::text[]`),
-	accessedServices: text("accesedServices")
-		.array()
-		.notNull()
-		.default(sql`ARRAY[]::text[]`),
-	adminId: text("adminId")
-		.notNull()
-		.references(() => admins.adminId, { onDelete: "cascade" }),
-	authId: text("authId")
-		.notNull()
-		.references(() => auth.id, { onDelete: "cascade" }),
-});
-
 // TEMP
 export const users_temp = pgTable("user_temp", {
 	id: text("id")
@@ -187,19 +141,11 @@ export const users_temp = pgTable("user_temp", {
 });
 
 export const usersRelations = relations(users_temp, ({ one, many }) => ({
-	// auth: one(auth, {
-	// 	fields: [users.authId],
-	// 	references: [auth.id],
-	// }),
 	account: one(account, {
 		fields: [users_temp.id],
 		references: [account.userId],
 	}),
 	organizations: many(organization),
-	// admin: one(admins, {
-	// 	fields: [users.adminId],
-	// 	references: [admins.adminId],
-	// }),
 	projects: many(projects),
 }));
 
@@ -263,3 +209,91 @@ export const apiFindOneUserByAuth = createSchema
 		// authId: true,
 	})
 	.required();
+export const apiSaveSSHKey = createSchema
+	.pick({
+		sshPrivateKey: true,
+	})
+	.required();
+
+export const apiAssignDomain = createSchema
+	.pick({
+		host: true,
+		certificateType: true,
+		letsEncryptEmail: true,
+	})
+	.required()
+	.partial({
+		letsEncryptEmail: true,
+	});
+
+export const apiUpdateDockerCleanup = createSchema
+	.pick({
+		enableDockerCleanup: true,
+	})
+	.required()
+	.extend({
+		serverId: z.string().optional(),
+	});
+
+export const apiTraefikConfig = z.object({
+	traefikConfig: z.string().min(1),
+});
+
+export const apiModifyTraefikConfig = z.object({
+	path: z.string().min(1),
+	traefikConfig: z.string().min(1),
+	serverId: z.string().optional(),
+});
+export const apiReadTraefikConfig = z.object({
+	path: z.string().min(1),
+	serverId: z.string().optional(),
+});
+
+export const apiEnableDashboard = z.object({
+	enableDashboard: z.boolean().optional(),
+	serverId: z.string().optional(),
+});
+
+export const apiServerSchema = z
+	.object({
+		serverId: z.string().optional(),
+	})
+	.optional();
+
+export const apiReadStatsLogs = z.object({
+	page: z
+		.object({
+			pageIndex: z.number(),
+			pageSize: z.number(),
+		})
+		.optional(),
+	status: z.string().array().optional(),
+	search: z.string().optional(),
+	sort: z.object({ id: z.string(), desc: z.boolean() }).optional(),
+});
+
+export const apiUpdateWebServerMonitoring = z.object({
+	metricsConfig: z
+		.object({
+			server: z.object({
+				refreshRate: z.number().min(2),
+				port: z.number().min(1),
+				token: z.string(),
+				urlCallback: z.string().url(),
+				retentionDays: z.number().min(1),
+				cronJob: z.string().min(1),
+				thresholds: z.object({
+					cpu: z.number().min(0),
+					memory: z.number().min(0),
+				}),
+			}),
+			containers: z.object({
+				refreshRate: z.number().min(2),
+				services: z.object({
+					include: z.array(z.string()).optional(),
+					exclude: z.array(z.string()).optional(),
+				}),
+			}),
+		})
+		.required(),
+});

packages/server/src/services/admin.ts

@@ -2,9 +2,7 @@ import { randomBytes } from "node:crypto";
 import { db } from "@dokploy/server/db";
 import {
 	account,
-	admins,
 	type apiCreateUserInvitation,
-	auth,
 	member,
 	organization,
 	users_temp,

packages/server/src/services/auth.ts

@@ -1,12 +1,6 @@
 import { randomBytes } from "node:crypto";
 import { db } from "@dokploy/server/db";
-import {
-	admins,
-	type apiCreateAdmin,
-	type apiCreateUser,
-	auth,
-	users_temp,
-} from "@dokploy/server/db/schema";
+import { users_temp } from "@dokploy/server/db/schema";
 import { getPublicIpWithFallback } from "@dokploy/server/wss/utils";
 import { TRPCError } from "@trpc/server";
 import * as bcrypt from "bcrypt";
@@ -17,89 +11,6 @@ import QRCode from "qrcode";
 import { IS_CLOUD } from "../constants";
 import { findUserById } from "./admin";
 
-export type Auth = typeof auth.$inferSelect;
-
-export const createAdmin = async (input: typeof apiCreateAdmin._type) => {
-	return await db.transaction(async (tx) => {
-		const hashedPassword = bcrypt.hashSync(input.password, 10);
-		const newAuth = await tx
-			.insert(auth)
-			.values({
-				email: input.email.toLowerCase(),
-				password: hashedPassword,
-				rol: "admin",
-			})
-			.returning()
-			.then((res) => res[0]);
-
-		if (!newAuth) {
-			throw new TRPCError({
-				code: "BAD_REQUEST",
-				message: "Error creating the user",
-			});
-		}
-
-		await tx
-			.insert(admins)
-			.values({
-				authId: newAuth.id,
-				...(!IS_CLOUD && {
-					serverIp:
-						process.env.ADVERTISE_ADDR || (await getPublicIpWithFallback()),
-				}),
-			})
-			.returning();
-
-		return newAuth;
-	});
-};
-
-export const createUser = async (input: typeof apiCreateUser._type) => {
-	return await db.transaction(async (tx) => {
-		const hashedPassword = bcrypt.hashSync(input.password, 10);
-		const res = await tx
-			.update(auth)
-			.set({
-				password: hashedPassword,
-			})
-			.where(eq(auth.id, input.id))
-			.returning()
-			.then((res) => res[0]);
-
-		if (!res) {
-			throw new TRPCError({
-				code: "BAD_REQUEST",
-				message: "Error creating the user",
-			});
-		}
-
-		const user = await tx
-			.update(users)
-			.set({
-				isRegistered: true,
-				expirationDate: undefined,
-			})
-			.where(eq(users.token, input.token))
-			.returning()
-			.then((res) => res[0]);
-
-		return user;
-	});
-};
-
-export const findAuthByEmail = async (email: string) => {
-	const result = await db.query.auth.findFirst({
-		where: eq(auth.email, email),
-	});
-	if (!result) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "User not found",
-		});
-	}
-	return result;
-};
-
 export const findAuthById = async (authId: string) => {
 	const result = await db.query.users_temp.findFirst({
 		where: eq(users_temp.id, authId),
@@ -117,21 +28,6 @@ export const findAuthById = async (authId: string) => {
 	return result;
 };
 
-export const updateAuthById = async (
-	authId: string,
-	authData: Partial<Auth>,
-) => {
-	const result = await db
-		.update(auth)
-		.set({
-			...authData,
-		})
-		.where(eq(auth.id, authId))
-		.returning();
-
-	return result[0];
-};
-
 export const generate2FASecret = async (userId: string) => {
 	const user = await findUserById(userId);