Index: database/drizzle/schema/relations.ts
===================================================================
--- database/drizzle/schema/relations.ts	(revision fdd776b4ca5fc651b66cb07a78a265c132fb9deb)
+++ database/drizzle/schema/relations.ts	(revision b61509428dd499dca1a8e5a5c5cf7cb9951f4d02)
@@ -7,28 +7,27 @@
     memoryTable,
     powerSupplyTable,
-    pcCaseTable,
+    pcCasesTable,
     caseStorageFormFactorsTable,
     casePsFormFactorsTable,
     caseMoboFormFactorsTable,
-    coolerTable,
+    coolersTable,
     coolerCPUSocketsTable,
-    motherboardTable,
+    motherboardsTable,
     storageTable,
-    memoryCardTable,
-    opticalDriveTable,
-    soundCardTable,
-    soundCardChannelsTable,
+    memoryCardsTable,
+    opticalDrivesTable,
+    soundCardsTable,
     cablesTable,
-    networkAdapterTable,
-    networkCardTable,
+    networkAdaptersTable,
+    networkCardsTable,
 
 } from "./components";
 
 import {
-    buildTable,
-    buildComponentTable,
-    favoriteBuildTable,
-    ratingBuildTable,
-    reviewTable
+    buildsTable,
+    buildComponentsTable,
+    favoriteBuildsTable,
+    ratingBuildsTable,
+    reviewsTable
 } from "./builds"
 
@@ -40,8 +39,8 @@
 
 export const usersRelations = relations(usersTable, ({ many, one }) => ({
-    builds: many(buildTable),
-    reviews: many(reviewTable),
-    favorites: many(favoriteBuildTable),
-    ratings: many(ratingBuildTable),
+    builds: many(buildsTable),
+    reviews: many(reviewsTable),
+    favorites: many(favoriteBuildsTable),
+    ratings: many(ratingBuildsTable),
     suggestions: many(suggestionsTable),
     adminProfile: one(adminsTable, {
@@ -70,61 +69,61 @@
 }));
 
-export const buildRelations = relations(buildTable, ({ one, many }) => ({
+export const buildRelations = relations(buildsTable, ({ one, many }) => ({
     owner: one(usersTable, {
-        fields: [buildTable.userId],
-        references: [usersTable.id],
-    }),
-    buildComponents: many(buildComponentTable),
-    favorites: many(favoriteBuildTable),
-    ratings: many(ratingBuildTable),
-    reviews: many(reviewTable),
-}));
-
-export const buildComponentRelations = relations(buildComponentTable, ({ one }) => ({
-    build: one(buildTable, {
-        fields: [buildComponentTable.buildId],
-        references: [buildTable.id],
-    }),
-    component: one(componentsTable, {
-        fields: [buildComponentTable.componentId],
-        references: [componentsTable.id],
-    }),
-}));
-
-export const favoriteBuildRelations = relations(favoriteBuildTable, ({ one }) => ({
+        fields: [buildsTable.userId],
+        references: [usersTable.id],
+    }),
+    buildComponents: many(buildComponentsTable),
+    favorites: many(favoriteBuildsTable),
+    ratings: many(ratingBuildsTable),
+    reviews: many(reviewsTable),
+}));
+
+export const buildComponentRelations = relations(buildComponentsTable, ({ one }) => ({
+    build: one(buildsTable, {
+        fields: [buildComponentsTable.buildId],
+        references: [buildsTable.id],
+    }),
+    component: one(componentsTable, {
+        fields: [buildComponentsTable.componentId],
+        references: [componentsTable.id],
+    }),
+}));
+
+export const favoriteBuildRelations = relations(favoriteBuildsTable, ({ one }) => ({
     user: one(usersTable, {
-        fields: [favoriteBuildTable.userId],
-        references: [usersTable.id],
-    }),
-    build: one(buildTable, {
-        fields: [favoriteBuildTable.buildId],
-        references: [buildTable.id],
-    }),
-}));
-
-export const ratingBuildRelations = relations(ratingBuildTable, ({ one }) => ({
+        fields: [favoriteBuildsTable.userId],
+        references: [usersTable.id],
+    }),
+    build: one(buildsTable, {
+        fields: [favoriteBuildsTable.buildId],
+        references: [buildsTable.id],
+    }),
+}));
+
+export const ratingBuildRelations = relations(ratingBuildsTable, ({ one }) => ({
     user: one(usersTable, {
-        fields: [ratingBuildTable.userId],
-        references: [usersTable.id],
-    }),
-    build: one(buildTable, {
-        fields: [ratingBuildTable.buildId],
-        references: [buildTable.id],
-    }),
-}));
-
-export const reviewRelations = relations(reviewTable, ({ one }) => ({
+        fields: [ratingBuildsTable.userId],
+        references: [usersTable.id],
+    }),
+    build: one(buildsTable, {
+        fields: [ratingBuildsTable.buildId],
+        references: [buildsTable.id],
+    }),
+}));
+
+export const reviewRelations = relations(reviewsTable, ({ one }) => ({
     author: one(usersTable, {
-        fields: [reviewTable.userId],
-        references: [usersTable.id],
-    }),
-    build: one(buildTable, {
-        fields: [reviewTable.buildId],
-        references: [buildTable.id],
+        fields: [reviewsTable.userId],
+        references: [usersTable.id],
+    }),
+    build: one(buildsTable, {
+        fields: [reviewsTable.buildId],
+        references: [buildsTable.id],
     }),
 }));
 
 export const componentsRelations = relations(componentsTable, ({ many, one }) => ({
-    buildComponents: many(buildComponentTable),
+    buildComponents: many(buildComponentsTable),
 
     cpu: one(CPUTable, {
@@ -144,15 +143,15 @@
         references: [powerSupplyTable.componentId]
     }),
-    pcCase: one(pcCaseTable, {
-        fields: [componentsTable.id],
-        references: [pcCaseTable.componentId]
-    }),
-    cooler: one(coolerTable, {
-        fields: [componentsTable.id],
-        references: [coolerTable.componentId]
-    }),
-    motherboard: one(motherboardTable, {
-        fields: [componentsTable.id],
-        references: [motherboardTable.componentId]
+    pcCase: one(pcCasesTable, {
+        fields: [componentsTable.id],
+        references: [pcCasesTable.componentId]
+    }),
+    cooler: one(coolersTable, {
+        fields: [componentsTable.id],
+        references: [coolersTable.componentId]
+    }),
+    motherboard: one(motherboardsTable, {
+        fields: [componentsTable.id],
+        references: [motherboardsTable.componentId]
     }),
     storage: one(storageTable, {
@@ -160,15 +159,15 @@
         references: [storageTable.componentId]
     }),
-    memoryCard: one(memoryCardTable, {
-        fields: [componentsTable.id],
-        references: [memoryCardTable.componentId]
-    }),
-    opticalDrive: one(opticalDriveTable, {
-        fields: [componentsTable.id],
-        references: [opticalDriveTable.componentId]
-    }),
-    soundCard: one(soundCardTable, {
-        fields: [componentsTable.id],
-        references: [soundCardTable.componentId]
+    memoryCard: one(memoryCardsTable, {
+        fields: [componentsTable.id],
+        references: [memoryCardsTable.componentId]
+    }),
+    opticalDrive: one(opticalDrivesTable, {
+        fields: [componentsTable.id],
+        references: [opticalDrivesTable.componentId]
+    }),
+    soundCard: one(soundCardsTable, {
+        fields: [componentsTable.id],
+        references: [soundCardsTable.componentId]
     }),
     cables: one(cablesTable, {
@@ -176,11 +175,11 @@
         references: [cablesTable.componentId]
     }),
-    networkAdapter: one(networkAdapterTable, {
-        fields: [componentsTable.id],
-        references: [networkAdapterTable.componentId]
-    }),
-    networkCard: one(networkCardTable, {
-        fields: [componentsTable.id],
-        references: [networkCardTable.componentId]
+    networkAdapter: one(networkAdaptersTable, {
+        fields: [componentsTable.id],
+        references: [networkAdaptersTable.componentId]
+    }),
+    networkCard: one(networkCardsTable, {
+        fields: [componentsTable.id],
+        references: [networkCardsTable.componentId]
     }),
 }));
@@ -214,7 +213,7 @@
 }));
 
-export const motherboardRelations = relations(motherboardTable, ({ one }) => ({
-    component: one(componentsTable, {
-        fields: [motherboardTable.componentId],
+export const motherboardRelations = relations(motherboardsTable, ({ one }) => ({
+    component: one(componentsTable, {
+        fields: [motherboardsTable.componentId],
         references: [componentsTable.id],
     }),
@@ -228,14 +227,14 @@
 }));
 
-export const memoryCardRelations = relations(memoryCardTable, ({ one }) => ({
-    component: one(componentsTable, {
-        fields: [memoryCardTable.componentId],
-        references: [componentsTable.id],
-    }),
-}));
-
-export const opticalDriveRelations = relations(opticalDriveTable, ({ one }) => ({
-    component: one(componentsTable, {
-        fields: [opticalDriveTable.componentId],
+export const memoryCardRelations = relations(memoryCardsTable, ({ one }) => ({
+    component: one(componentsTable, {
+        fields: [memoryCardsTable.componentId],
+        references: [componentsTable.id],
+    }),
+}));
+
+export const opticalDriveRelations = relations(opticalDrivesTable, ({ one }) => ({
+    component: one(componentsTable, {
+        fields: [opticalDrivesTable.componentId],
         references: [componentsTable.id],
     }),
@@ -249,21 +248,21 @@
 }));
 
-export const networkAdapterRelations = relations(networkAdapterTable, ({ one }) => ({
-    component: one(componentsTable, {
-        fields: [networkAdapterTable.componentId],
-        references: [componentsTable.id],
-    }),
-}));
-
-export const networkCardRelations = relations(networkCardTable, ({ one }) => ({
-    component: one(componentsTable, {
-        fields: [networkCardTable.componentId],
-        references: [componentsTable.id],
-    }),
-}));
-
-export const pcCaseRelations = relations(pcCaseTable, ({ one, many }) => ({
-    component: one(componentsTable, {
-        fields: [pcCaseTable.componentId],
+export const networkAdapterRelations = relations(networkAdaptersTable, ({ one }) => ({
+    component: one(componentsTable, {
+        fields: [networkAdaptersTable.componentId],
+        references: [componentsTable.id],
+    }),
+}));
+
+export const networkCardRelations = relations(networkCardsTable, ({ one }) => ({
+    component: one(componentsTable, {
+        fields: [networkCardsTable.componentId],
+        references: [componentsTable.id],
+    }),
+}));
+
+export const pcCaseRelations = relations(pcCasesTable, ({ one, many }) => ({
+    component: one(componentsTable, {
+        fields: [pcCasesTable.componentId],
         references: [componentsTable.id],
     }),
@@ -274,27 +273,27 @@
 
 export const caseStorageFormFactorsRelations = relations(caseStorageFormFactorsTable, ({ one }) => ({
-    pcCase: one(pcCaseTable, {
+    pcCase: one(pcCasesTable, {
         fields: [caseStorageFormFactorsTable.caseId],
-        references: [pcCaseTable.componentId],
+        references: [pcCasesTable.componentId],
     }),
 }));
 
 export const casePsFormFactorsRelations = relations(casePsFormFactorsTable, ({ one }) => ({
-    pcCase: one(pcCaseTable, {
+    pcCase: one(pcCasesTable, {
         fields: [casePsFormFactorsTable.caseId],
-        references: [pcCaseTable.componentId],
+        references: [pcCasesTable.componentId],
     }),
 }));
 
 export const caseMoboFormFactorsRelations = relations(caseMoboFormFactorsTable, ({ one }) => ({
-    pcCase: one(pcCaseTable, {
+    pcCase: one(pcCasesTable, {
         fields: [caseMoboFormFactorsTable.caseId],
-        references: [pcCaseTable.componentId],
-    }),
-}));
-
-export const coolerRelations = relations(coolerTable, ({ one, many }) => ({
-    component: one(componentsTable, {
-        fields: [coolerTable.componentId],
+        references: [pcCasesTable.componentId],
+    }),
+}));
+
+export const coolerRelations = relations(coolersTable, ({ one, many }) => ({
+    component: one(componentsTable, {
+        fields: [coolersTable.componentId],
         references: [componentsTable.id],
     }),
@@ -303,22 +302,14 @@
 
 export const coolerCpuSocketsRelations = relations(coolerCPUSocketsTable, ({ one }) => ({
-    cooler: one(coolerTable, {
+    cooler: one(coolersTable, {
         fields: [coolerCPUSocketsTable.cooler_id],
-        references: [coolerTable.componentId],
-    }),
-}));
-
-export const soundCardRelations = relations(soundCardTable, ({ one, many }) => ({
-    component: one(componentsTable, {
-        fields: [soundCardTable.componentId],
-        references: [componentsTable.id],
-    }),
-    channels: many(soundCardChannelsTable),
-}));
-
-export const soundCardChannelsRelations = relations(soundCardChannelsTable, ({ one }) => ({
-    soundCard: one(soundCardTable, {
-        fields: [soundCardChannelsTable.soundCardId],
-        references: [soundCardTable.componentId],
-    }),
-}));
+        references: [coolersTable.componentId],
+    }),
+}));
+
+export const soundCardRelations = relations(soundCardsTable, ({ one, many }) => ({
+    component: one(componentsTable, {
+        fields: [soundCardsTable.componentId],
+        references: [componentsTable.id],
+    }),
+}));