Index: database/drizzle/schema/builds.ts
===================================================================
--- database/drizzle/schema/builds.ts	(revision fdd776b4ca5fc651b66cb07a78a265c132fb9deb)
+++ database/drizzle/schema/builds.ts	(revision fdd776b4ca5fc651b66cb07a78a265c132fb9deb)
@@ -0,0 +1,83 @@
+import { pgTable, serial, integer, text, numeric, boolean, date, primaryKey } from "drizzle-orm/pg-core";
+import { usersTable } from "./users";
+import { componentsTable } from "./components";
+
+export const buildTable = pgTable("build", {
+    id: serial("id").primaryKey(),
+    userId: integer("user_id")
+        .notNull()
+        .references(() => usersTable.id, { onDelete: "cascade", onUpdate: "cascade" }),
+    name: text("name").notNull(),
+    createdAt: date("created_at").notNull(),
+    description: text("description"),
+    totalPrice: numeric("total_price").notNull(),
+    isApproved: boolean("is_approved").notNull(),
+});
+
+export const buildComponentTable = pgTable("build_component", {
+        buildId: integer("build_id")
+            .notNull()
+            .references(() => buildTable.id, { onDelete: "cascade", onUpdate: "cascade" }),
+        componentId: integer("component_id")
+            .notNull()
+            .references(() => componentsTable.id, { onDelete: "cascade", onUpdate: "cascade" }),
+    },
+    (t) => ({
+        pk: primaryKey({ columns: [t.buildId, t.componentId] }),
+    }),
+);
+
+export const favoriteBuildTable = pgTable("favorite_build", {
+        buildId: integer("build_id")
+            .notNull()
+            .references(() => buildTable.id, { onDelete: "cascade", onUpdate: "cascade" }),
+        userId: integer("user_id")
+            .notNull()
+            .references(() => usersTable.id, { onDelete: "cascade", onUpdate: "cascade" }),
+    },
+    (t) => ({
+        pk: primaryKey({ columns: [t.buildId, t.userId] }),
+    }),
+);
+
+export const ratingBuildTable = pgTable("rating_build", {
+        buildId: integer("build_id")
+            .notNull()
+            .references(() => buildTable.id, { onDelete: "cascade", onUpdate: "cascade" }),
+        userId: integer("user_id")
+            .notNull()
+            .references(() => usersTable.id, { onDelete: "cascade", onUpdate: "cascade" }),
+        value: numeric("value").notNull(),
+    },
+    (t) => ({
+        pk: primaryKey({ columns: [t.buildId, t.userId] }),
+    }),
+);
+
+export const reviewTable = pgTable("review", {
+    id: serial("id").primaryKey(),
+
+    buildId: integer("build_id")
+        .notNull()
+        .references(() => buildTable.id, { onDelete: "cascade", onUpdate: "cascade" }),
+    userId: integer("user_id")
+        .notNull()
+        .references(() => usersTable.id, { onDelete: "cascade", onUpdate: "cascade" }),
+    content: text("content").notNull(),
+    createdAt: date("created_at").notNull(),
+});
+
+export type buildItem = typeof buildTable.$inferSelect;
+export type buildInsert = typeof buildTable.$inferInsert;
+
+export type buildComponentItem = typeof buildComponentTable.$inferSelect;
+export type buildComponentInsert = typeof buildComponentTable.$inferInsert;
+
+export type favoriteBuildItem = typeof favoriteBuildTable.$inferSelect;
+export type favoriteBuildInsert = typeof favoriteBuildTable.$inferInsert;
+
+export type ratingBuildItem = typeof ratingBuildTable.$inferSelect;
+export type ratingBuildInsert = typeof ratingBuildTable.$inferInsert;
+
+export type reviewItem = typeof reviewTable.$inferSelect;
+export type reviewInsert = typeof reviewTable.$inferInsert;
Index: database/drizzle/schema/components.ts
===================================================================
--- database/drizzle/schema/components.ts	(revision fdd776b4ca5fc651b66cb07a78a265c132fb9deb)
+++ database/drizzle/schema/components.ts	(revision fdd776b4ca5fc651b66cb07a78a265c132fb9deb)
@@ -0,0 +1,267 @@
+import { pgTable, serial, integer, text, numeric, boolean, date, primaryKey } from "drizzle-orm/pg-core";
+
+export const componentsTable = pgTable("components", {
+    id: serial("id").primaryKey(),
+    name: text("name").notNull(),
+    brand: text("brand").notNull(),
+    price: numeric("price").notNull(),
+    imgUrl: text("img_url"),
+});
+
+// Base Components
+export const CPUTable = pgTable("cpu", {
+    componentId: integer("component_id")
+        .primaryKey()
+        .references(() => componentsTable.id, { onDelete: "cascade", onUpdate: "cascade" }),
+    socket: text("socket").notNull(),
+    cores: integer("cores").notNull(),
+    threads: integer("threads").notNull(),
+    baseClock: numeric("base_clock").notNull(),
+    boostClock: numeric("boost_clock"),
+    tdp: numeric("tdp").notNull(),
+});
+
+export const GPUTable = pgTable("gpu", {
+    componentId: integer("component_id")
+        .primaryKey()
+        .references(() => componentsTable.id, { onDelete: "cascade", onUpdate: "cascade" }),
+    vram: numeric("vram").notNull(),
+    tdp: numeric("tdp").notNull(),
+    baseClock: numeric("base_clock"),
+    boostClock: numeric("boost_clock"),
+    chipset: text("chipset").notNull(),
+    length: numeric("length").notNull(),
+});
+
+export const memoryTable = pgTable("memory", {
+    componentId: integer("component_id")
+        .primaryKey()
+        .references(() => componentsTable.id, { onDelete: "cascade", onUpdate: "cascade" }),
+    type: text("type").notNull(),
+    speed: numeric("speed").notNull(),
+    capacity: numeric("capacity").notNull(),
+    modules: integer("modules").notNull(),
+});
+
+export const powerSupplyTable = pgTable("power_supply", {
+    componentId: integer("component_id")
+        .primaryKey()
+        .references(() => componentsTable.id, { onDelete: "cascade", onUpdate: "cascade" }),
+    type: text("type").notNull(),
+    wattage: numeric("wattage").notNull(),
+    formFactor: text("form_factor").notNull(),
+});
+
+export const pcCaseTable = pgTable("pc_case", {
+    componentId: integer("component_id")
+        .primaryKey()
+        .references(() => componentsTable.id, { onDelete: "cascade", onUpdate: "cascade" }),
+    coolerMaxHeight: numeric("cooler_max_height").notNull(),
+    gpuMaxLength: numeric("gpu_max_length").notNull(),
+});
+
+// Case multi-values
+export const caseStorageFormFactorsTable = pgTable("case_storage_form_factors", {
+        caseId: integer("case_id")
+            .notNull()
+            .references(() => pcCaseTable.componentId, {onDelete: "cascade", onUpdate: "cascade" }),
+        formFactor: text("form_factor").notNull(),
+    },
+    (t) => ({
+        pk: primaryKey({ columns: [t.caseId, t.formFactor] }),
+    }),
+);
+
+export const casePsFormFactorsTable = pgTable( "case_ps_form_factors", {
+        caseId: integer("case_id")
+            .notNull()
+            .references(() => pcCaseTable.componentId, { onDelete: "cascade", onUpdate: "cascade"}),
+        formFactor: text("form_factor").notNull(),
+    },
+    (t) => ({
+        pk: primaryKey({ columns: [t.caseId, t.formFactor] }),
+    }),
+);
+
+export const caseMoboFormFactorsTable = pgTable("case_mobo_form_factors", {
+        caseId: integer("case_id")
+            .notNull()
+            .references(() => pcCaseTable.componentId, { onDelete: "cascade", onUpdate: "cascade"}),
+        formFactor: text("form_factor").notNull(),
+    },
+    (t) => ({
+        pk: primaryKey({ columns: [t.caseId, t.formFactor] }),
+    }),
+);
+
+export const coolerTable = pgTable("cooler", {
+    componentId: integer("component_id")
+        .primaryKey()
+        .references(() => componentsTable.id, { onDelete: "cascade", onUpdate: "cascade" }),
+    type: text("type").notNull(),
+    height: numeric("height").notNull(),
+    maxTdpSupported: numeric("max_tdp_supported").notNull(),
+});
+
+// Cooler multi-values
+export const coolerCPUSocketsTable = pgTable("cooler_cpu_sockets", {
+        cooler_id: integer("cooler_id")
+            .notNull()
+            .references(() => coolerTable.componentId, { onDelete: "cascade", onUpdate: "cascade" }),
+        socket: text("socket").notNull(),
+    },
+    (t) => ({
+        pk: primaryKey({ columns: [t.cooler_id, t.socket] }),
+    })
+);
+
+export const motherboardTable = pgTable("motherboard", {
+    componentId: integer("component_id")
+        .primaryKey()
+        .references(() => componentsTable.id, { onDelete: "cascade", onUpdate: "cascade" }),
+
+    socket: text("socket").notNull(),
+    chipset: text("chipset").notNull(),
+    formFactor: text("form_factor").notNull(),
+    ramType: text("ram_type").notNull(),
+    numRamSlots: integer("num_ram_slots").notNull(),
+    maxRamCapacity: numeric("max_ram_capacity").notNull(),
+});
+
+export const storageTable = pgTable("storage", {
+    componentId: integer("component_id")
+        .primaryKey()
+        .references(() => componentsTable.id, { onDelete: "cascade", onUpdate: "cascade" }),
+    type: text("type").notNull(),
+    capacity: numeric("capacity").notNull(),
+    formFactor: text("form_factor").notNull(),
+});
+
+// Other Components
+export const memoryCardTable = pgTable("memory_card", {
+    componentId: integer("component_id")
+        .primaryKey()
+        .references(() => componentsTable.id, { onDelete: "cascade", onUpdate: "cascade" }),
+    numSlots: integer("num_slots").notNull(),
+    interface: text("interface").notNull(),
+});
+
+export const opticalDriveTable = pgTable("optical_drive", {
+    componentId: integer("component_id")
+        .primaryKey()
+        .references(() => componentsTable.id, { onDelete: "cascade", onUpdate: "cascade" }),
+    formFactor: text("form_factor").notNull(),
+    type: text("type").notNull(),
+    interface: text("interface").notNull(),
+    writeSpeed: numeric("write_speed").notNull(),
+    readSpeed: numeric("read_speed").notNull(),
+});
+
+export const soundCardTable = pgTable("sound_card", {
+    componentId: integer("component_id")
+        .primaryKey()
+        .references(() => componentsTable.id, { onDelete: "cascade", onUpdate: "cascade" }),
+    sampleRate: numeric("sample_rate").notNull(),
+    bitDepth: numeric("bit_depth").notNull(),
+    chipset: text("chipset").notNull(),
+    interface: text("interface").notNull(),
+});
+
+// SoundCard multi-values
+export const soundCardChannelsTable = pgTable("sound_card_channels", {
+        soundCardId: integer("sound_card_id")
+            .notNull()
+            .references(() => soundCardTable.componentId, { onDelete: "cascade", onUpdate: "cascade" }),
+        channel: text("channel").notNull(),
+    },
+    (t) => ({
+        pk: primaryKey({ columns: [t.soundCardId, t.channel] }),
+    })
+);
+
+export const cablesTable = pgTable("cables", {
+    componentId: integer("component_id")
+        .primaryKey()
+        .references(() => componentsTable.id, { onDelete: "cascade", onUpdate: "cascade" }),
+    lengthCm: numeric("length_cm").notNull(),
+    type: text("type").notNull(),
+});
+
+export const networkAdapterTable = pgTable("network_adapter", {
+    componentId: integer("component_id")
+        .primaryKey()
+        .references(() => componentsTable.id, { onDelete: "cascade", onUpdate: "cascade" }),
+    wifiVersion: text("wifi_version").notNull(),
+    interface: text("interface").notNull(),
+    numAntennas: integer("num_antennas").notNull(),
+});
+
+export const networkCardTable = pgTable("network_card", {
+    componentId: integer("component_id")
+        .primaryKey()
+        .references(() => componentsTable.id, { onDelete: "cascade", onUpdate: "cascade" }),
+    numPorts: integer("num_ports").notNull(),
+    speed: numeric("speed").notNull(),
+    interface: text("interface").notNull(),
+});
+
+export type componentItem = typeof componentsTable.$inferSelect;
+export type componentInsert = typeof componentsTable.$inferInsert;
+
+export type cpuItem = typeof CPUTable.$inferSelect;
+export type cpuInsert = typeof CPUTable.$inferInsert;
+
+export type gpuItem = typeof GPUTable.$inferSelect;
+export type gpuInsert = typeof GPUTable.$inferInsert;
+
+export type memoryItem = typeof memoryTable.$inferSelect;
+export type memoryInsert = typeof memoryTable.$inferInsert;
+
+export type powerSupplyItem = typeof powerSupplyTable.$inferSelect;
+export type powerSupplyInsert = typeof powerSupplyTable.$inferInsert;
+
+export type caseItem = typeof pcCaseTable.$inferSelect;
+export type caseInsert = typeof pcCaseTable.$inferInsert;
+
+export type caseStorageFormFactorsItem = typeof caseStorageFormFactorsTable.$inferSelect;
+export type caseStorageFormFactorsInsert = typeof caseStorageFormFactorsTable.$inferInsert;
+
+export type casePsFormFactorsItem = typeof casePsFormFactorsTable.$inferSelect;
+export type casePsFormFactorsInsert = typeof casePsFormFactorsTable.$inferInsert;
+
+export type caseMoboFormFactorsItem = typeof caseMoboFormFactorsTable.$inferSelect;
+export type caseMoboFormFactorsInsert = typeof caseMoboFormFactorsTable.$inferInsert;
+
+export type coolerItem = typeof coolerTable.$inferSelect;
+export type coolerInsert = typeof coolerTable.$inferInsert;
+
+export type coolerCPUSocketsItem = typeof coolerCPUSocketsTable.$inferSelect;
+export type coolerCPUSocketsInsert = typeof coolerCPUSocketsTable.$inferInsert;
+
+export type motherboardItem = typeof motherboardTable.$inferSelect;
+export type motherboardInsert = typeof motherboardTable.$inferInsert;
+
+export type storageItem = typeof storageTable.$inferSelect;
+export type storageInsert = typeof storageTable.$inferInsert
+
+export type memoryCardItem = typeof memoryCardTable.$inferSelect;
+export type memoryCardInsert = typeof memoryCardTable.$inferInsert;
+
+export type opticalDriveItem = typeof opticalDriveTable.$inferSelect;
+export type opticalDriveInsert = typeof opticalDriveTable.$inferInsert;
+
+export type soundCardItem = typeof soundCardTable.$inferSelect;
+export type soundCardInsert = typeof soundCardTable.$inferInsert;
+
+export type soundCardChannelsItem = typeof soundCardChannelsTable.$inferSelect;
+export type soundCardChannelsInsert = typeof soundCardChannelsTable.$inferInsert;
+
+export type cablesItem = typeof cablesTable.$inferSelect;
+export type cablesInsert = typeof cablesTable.$inferInsert;
+
+export type networkAdapterItem = typeof networkAdapterTable.$inferSelect;
+export type networkAdapterInsert = typeof networkAdapterTable.$inferInsert;
+
+export type networkCardItem = typeof networkCardTable.$inferSelect;
+export type networkCardInsert = typeof networkCardTable.$inferInsert;
+
Index: database/drizzle/schema/index.ts
===================================================================
--- database/drizzle/schema/index.ts	(revision fdd776b4ca5fc651b66cb07a78a265c132fb9deb)
+++ database/drizzle/schema/index.ts	(revision fdd776b4ca5fc651b66cb07a78a265c132fb9deb)
@@ -0,0 +1,4 @@
+export * from "./builds";
+export * from "./components";
+export * from "./relations";
+export * from "./users";
Index: database/drizzle/schema/relations.ts
===================================================================
--- database/drizzle/schema/relations.ts	(revision fdd776b4ca5fc651b66cb07a78a265c132fb9deb)
+++ database/drizzle/schema/relations.ts	(revision fdd776b4ca5fc651b66cb07a78a265c132fb9deb)
@@ -0,0 +1,324 @@
+import { relations } from "drizzle-orm";
+
+import {
+    componentsTable,
+    CPUTable,
+    GPUTable,
+    memoryTable,
+    powerSupplyTable,
+    pcCaseTable,
+    caseStorageFormFactorsTable,
+    casePsFormFactorsTable,
+    caseMoboFormFactorsTable,
+    coolerTable,
+    coolerCPUSocketsTable,
+    motherboardTable,
+    storageTable,
+    memoryCardTable,
+    opticalDriveTable,
+    soundCardTable,
+    soundCardChannelsTable,
+    cablesTable,
+    networkAdapterTable,
+    networkCardTable,
+
+} from "./components";
+
+import {
+    buildTable,
+    buildComponentTable,
+    favoriteBuildTable,
+    ratingBuildTable,
+    reviewTable
+} from "./builds"
+
+import {
+    usersTable,
+    adminsTable,
+    suggestionsTable
+} from "./users";
+
+export const usersRelations = relations(usersTable, ({ many, one }) => ({
+    builds: many(buildTable),
+    reviews: many(reviewTable),
+    favorites: many(favoriteBuildTable),
+    ratings: many(ratingBuildTable),
+    suggestions: many(suggestionsTable),
+    adminProfile: one(adminsTable, {
+        fields: [usersTable.id],
+        references: [adminsTable.userId],
+    })
+}));
+
+export const adminsRelations = relations(adminsTable, ({ one, many }) => ({
+    user: one(usersTable, {
+        fields: [adminsTable.userId],
+        references: [usersTable.id],
+    }),
+    moderatedSuggestions: many(suggestionsTable),
+}));
+
+export const suggestionsRelations = relations(suggestionsTable, ({ one }) => ({
+    author: one(usersTable, {
+        fields: [suggestionsTable.userId],
+        references: [usersTable.id],
+    }),
+    moderator: one(adminsTable, {
+        fields: [suggestionsTable.adminId],
+        references: [adminsTable.userId],
+    }),
+}));
+
+export const buildRelations = relations(buildTable, ({ 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 }) => ({
+    user: one(usersTable, {
+        fields: [favoriteBuildTable.userId],
+        references: [usersTable.id],
+    }),
+    build: one(buildTable, {
+        fields: [favoriteBuildTable.buildId],
+        references: [buildTable.id],
+    }),
+}));
+
+export const ratingBuildRelations = relations(ratingBuildTable, ({ 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 }) => ({
+    author: one(usersTable, {
+        fields: [reviewTable.userId],
+        references: [usersTable.id],
+    }),
+    build: one(buildTable, {
+        fields: [reviewTable.buildId],
+        references: [buildTable.id],
+    }),
+}));
+
+export const componentsRelations = relations(componentsTable, ({ many, one }) => ({
+    buildComponents: many(buildComponentTable),
+
+    cpu: one(CPUTable, {
+        fields: [componentsTable.id],
+        references: [CPUTable.componentId]
+    }),
+    gpu: one(GPUTable, {
+        fields: [componentsTable.id],
+        references: [GPUTable.componentId]
+    }),
+    memory: one(memoryTable, {
+        fields: [componentsTable.id],
+        references: [memoryTable.componentId]
+    }),
+    powerSupply: one(powerSupplyTable, {
+        fields: [componentsTable.id],
+        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]
+    }),
+    storage: one(storageTable, {
+        fields: [componentsTable.id],
+        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]
+    }),
+    cables: one(cablesTable, {
+        fields: [componentsTable.id],
+        references: [cablesTable.componentId]
+    }),
+    networkAdapter: one(networkAdapterTable, {
+        fields: [componentsTable.id],
+        references: [networkAdapterTable.componentId]
+    }),
+    networkCard: one(networkCardTable, {
+        fields: [componentsTable.id],
+        references: [networkCardTable.componentId]
+    }),
+}));
+
+export const cpuRelations = relations(CPUTable, ({ one }) => ({
+    component: one(componentsTable, {
+        fields: [CPUTable.componentId],
+        references: [componentsTable.id],
+    }),
+}));
+
+export const gpuRelations = relations(GPUTable, ({ one }) => ({
+    component: one(componentsTable, {
+        fields: [GPUTable.componentId],
+        references: [componentsTable.id],
+    }),
+}));
+
+export const memoryRelations = relations(memoryTable, ({ one }) => ({
+    component: one(componentsTable, {
+        fields: [memoryTable.componentId],
+        references: [componentsTable.id],
+    }),
+}));
+
+export const powerSupplyRelations = relations(powerSupplyTable, ({ one }) => ({
+    component: one(componentsTable, {
+        fields: [powerSupplyTable.componentId],
+        references: [componentsTable.id],
+    }),
+}));
+
+export const motherboardRelations = relations(motherboardTable, ({ one }) => ({
+    component: one(componentsTable, {
+        fields: [motherboardTable.componentId],
+        references: [componentsTable.id],
+    }),
+}));
+
+export const storageRelations = relations(storageTable, ({ one }) => ({
+    component: one(componentsTable, {
+        fields: [storageTable.componentId],
+        references: [componentsTable.id],
+    }),
+}));
+
+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],
+        references: [componentsTable.id],
+    }),
+}));
+
+export const cablesRelations = relations(cablesTable, ({ one }) => ({
+    component: one(componentsTable, {
+        fields: [cablesTable.componentId],
+        references: [componentsTable.id],
+    }),
+}));
+
+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],
+        references: [componentsTable.id],
+    }),
+    storageFormFactors: many(caseStorageFormFactorsTable),
+    psFormFactors: many(casePsFormFactorsTable),
+    moboFormFactors: many(caseMoboFormFactorsTable),
+}));
+
+export const caseStorageFormFactorsRelations = relations(caseStorageFormFactorsTable, ({ one }) => ({
+    pcCase: one(pcCaseTable, {
+        fields: [caseStorageFormFactorsTable.caseId],
+        references: [pcCaseTable.componentId],
+    }),
+}));
+
+export const casePsFormFactorsRelations = relations(casePsFormFactorsTable, ({ one }) => ({
+    pcCase: one(pcCaseTable, {
+        fields: [casePsFormFactorsTable.caseId],
+        references: [pcCaseTable.componentId],
+    }),
+}));
+
+export const caseMoboFormFactorsRelations = relations(caseMoboFormFactorsTable, ({ one }) => ({
+    pcCase: one(pcCaseTable, {
+        fields: [caseMoboFormFactorsTable.caseId],
+        references: [pcCaseTable.componentId],
+    }),
+}));
+
+export const coolerRelations = relations(coolerTable, ({ one, many }) => ({
+    component: one(componentsTable, {
+        fields: [coolerTable.componentId],
+        references: [componentsTable.id],
+    }),
+    cpuSockets: many(coolerCPUSocketsTable),
+}));
+
+export const coolerCpuSocketsRelations = relations(coolerCPUSocketsTable, ({ one }) => ({
+    cooler: one(coolerTable, {
+        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],
+    }),
+}));
Index: database/drizzle/schema/users.ts
===================================================================
--- database/drizzle/schema/users.ts	(revision fdd776b4ca5fc651b66cb07a78a265c132fb9deb)
+++ database/drizzle/schema/users.ts	(revision fdd776b4ca5fc651b66cb07a78a265c132fb9deb)
@@ -0,0 +1,39 @@
+import { pgTable, serial, integer, text, numeric, boolean, date, primaryKey } from "drizzle-orm/pg-core";
+
+export const usersTable = pgTable("users", {
+    id: serial("id").primaryKey(),
+    username: text("username").notNull().unique(),
+    passwordHash: text("password").notNull(),
+    email: text("email").notNull().unique()
+})
+
+export const adminsTable = pgTable("admins", {
+    userId: integer("user_id")
+        .primaryKey()
+        .references(() => usersTable.id, { onDelete: 'cascade', onUpdate: 'cascade' })
+})
+
+export const suggestionsTable = pgTable("suggestions", {
+    id: serial("id").primaryKey(),
+    userId: integer("user_id")
+        .notNull()
+        .references(() => usersTable.id, { onDelete: 'cascade', onUpdate: 'cascade' }),
+    adminId: integer("admin_id")
+        .references(() => adminsTable.userId, { onDelete: 'set null', onUpdate: 'cascade' }),
+    link: text("link").notNull(),
+    adminComment: text("admin_comment"),
+    description: text("description"),
+    status: text("status")
+        .notNull()
+        .default("pending"), // Pending, Approved, Rejected
+    componentType: text("component_type").notNull()
+});
+
+export type userItem = typeof usersTable.$inferSelect;
+export type userInsert = typeof usersTable.$inferInsert;
+
+export type adminItem = typeof adminsTable.$inferSelect;
+export type adminInsert = typeof adminsTable.$inferInsert;
+
+export type suggestionItem = typeof suggestionsTable.$inferSelect;
+export type suggestionInsert = typeof suggestionsTable.$inferInsert;