merge: convert to bun workspaces monorepo

apps/web/lib/db/index.ts

@@ -0,0 +1,9 @@
+import { drizzle } from "drizzle-orm/node-postgres"
+import { Pool } from "pg"
+import * as schema from "./schema"
+
+const pool = new Pool({
+  connectionString: process.env.DATABASE_URL,
+})
+
+export const db = drizzle(pool, { schema })

apps/web/lib/db/migrations/backfill-slugs.ts

@@ -0,0 +1,50 @@
+import { db } from "@/lib/db/index"
+import { games } from "@/lib/db/schema"
+import { generateSlug } from "@/lib/utils/slug"
+import { ne, isNull, isNotNull, and, eq } from "drizzle-orm"
+
+async function backfillSlugs() {
+  const nonSteamGames = await db
+    .select({ id: games.id, title: games.title })
+    .from(games)
+    .where(and(ne(games.source, "steam"), isNull(games.slug)))
+
+  console.log(`Found ${nonSteamGames.length} non-Steam games without slugs`)
+
+  const usedSlugs = new Set<string>()
+  const existing = await db
+    .select({ slug: games.slug })
+    .from(games)
+    .where(isNotNull(games.slug))
+  for (const row of existing) {
+    if (row.slug) usedSlugs.add(row.slug)
+  }
+
+  let updated = 0
+  let errors = 0
+  for (const game of nonSteamGames) {
+    let slug = generateSlug(game.title)
+    if (!slug) {
+      slug = `game-${game.id.slice(0, 8)}`
+    }
+    let candidate = slug
+    let suffix = 2
+    while (usedSlugs.has(candidate)) {
+      candidate = `${slug}-${suffix}`
+      suffix++
+    }
+    usedSlugs.add(candidate)
+    try {
+      await db.update(games).set({ slug: candidate }).where(eq(games.id, game.id))
+      updated++
+    } catch (err) {
+      console.error(`Failed to update ${game.title} (${game.id}):`, err)
+      errors++
+    }
+  }
+  console.log(`Backfill complete: ${updated} updated, ${errors} errors`)
+}
+
+backfillSlugs()
+  .then(() => process.exit(0))
+  .catch((err) => { console.error("Backfill failed:", err); process.exit(1) })

apps/web/lib/db/schema/auth.ts

@@ -0,0 +1,180 @@
+import { relations } from "drizzle-orm"
+import {
+  pgTable,
+  text,
+  timestamp,
+  boolean,
+  integer,
+  index,
+} from "drizzle-orm/pg-core"
+
+export const user = pgTable("user", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  email: text("email").notNull().unique(),
+  emailVerified: boolean("email_verified").default(false).notNull(),
+  image: text("image"),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at")
+    .defaultNow()
+    .$onUpdate(() => /* @__PURE__ */ new Date())
+    .notNull(),
+  role: text("role"),
+  banned: boolean("banned").default(false),
+  banReason: text("ban_reason"),
+  banExpires: timestamp("ban_expires"),
+  lastLoginMethod: text("last_login_method"),
+})
+
+export const session = pgTable(
+  "session",
+  {
+    id: text("id").primaryKey(),
+    expiresAt: timestamp("expires_at").notNull(),
+    token: text("token").notNull().unique(),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at")
+      .$onUpdate(() => /* @__PURE__ */ new Date())
+      .notNull(),
+    ipAddress: text("ip_address"),
+    userAgent: text("user_agent"),
+    userId: text("user_id")
+      .notNull()
+      .references(() => user.id, { onDelete: "cascade" }),
+    impersonatedBy: text("impersonated_by"),
+  },
+  (table) => [index("session_userId_idx").on(table.userId)],
+)
+
+export const account = pgTable(
+  "account",
+  {
+    id: text("id").primaryKey(),
+    accountId: text("account_id").notNull(),
+    providerId: text("provider_id").notNull(),
+    userId: text("user_id")
+      .notNull()
+      .references(() => user.id, { onDelete: "cascade" }),
+    accessToken: text("access_token"),
+    refreshToken: text("refresh_token"),
+    idToken: text("id_token"),
+    accessTokenExpiresAt: timestamp("access_token_expires_at"),
+    refreshTokenExpiresAt: timestamp("refresh_token_expires_at"),
+    scope: text("scope"),
+    password: text("password"),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at")
+      .$onUpdate(() => /* @__PURE__ */ new Date())
+      .notNull(),
+  },
+  (table) => [index("account_userId_idx").on(table.userId)],
+)
+
+export const verification = pgTable(
+  "verification",
+  {
+    id: text("id").primaryKey(),
+    identifier: text("identifier").notNull(),
+    value: text("value").notNull(),
+    expiresAt: timestamp("expires_at").notNull(),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at")
+      .defaultNow()
+      .$onUpdate(() => /* @__PURE__ */ new Date())
+      .notNull(),
+  },
+  (table) => [index("verification_identifier_idx").on(table.identifier)],
+)
+
+export const passkey = pgTable(
+  "passkey",
+  {
+    id: text("id").primaryKey(),
+    name: text("name"),
+    publicKey: text("public_key").notNull(),
+    userId: text("user_id")
+      .notNull()
+      .references(() => user.id, { onDelete: "cascade" }),
+    credentialID: text("credential_id").notNull(),
+    counter: integer("counter").notNull(),
+    deviceType: text("device_type").notNull(),
+    backedUp: boolean("backed_up").notNull(),
+    transports: text("transports"),
+    createdAt: timestamp("created_at"),
+    aaguid: text("aaguid"),
+  },
+  (table) => [
+    index("passkey_userId_idx").on(table.userId),
+    index("passkey_credentialID_idx").on(table.credentialID),
+  ],
+)
+
+export const userRelations = relations(user, ({ many }) => ({
+  sessions: many(session),
+  accounts: many(account),
+  passkeys: many(passkey),
+}))
+
+export const sessionRelations = relations(session, ({ one }) => ({
+  user: one(user, {
+    fields: [session.userId],
+    references: [user.id],
+  }),
+}))
+
+export const accountRelations = relations(account, ({ one }) => ({
+  user: one(user, {
+    fields: [account.userId],
+    references: [user.id],
+  }),
+}))
+
+export const passkeyRelations = relations(passkey, ({ one }) => ({
+  user: one(user, {
+    fields: [passkey.userId],
+    references: [user.id],
+  }),
+}))
+
+export const apikey = pgTable(
+  "apikey",
+  {
+    id: text("id").primaryKey(),
+    configId: text("config_id").notNull().default("default"),
+    name: text("name"),
+    start: text("start"),
+    referenceId: text("reference_id").notNull(),
+    prefix: text("prefix"),
+    key: text("key").notNull(),
+    refillInterval: integer("refill_interval"),
+    refillAmount: integer("refill_amount"),
+    lastRefillAt: timestamp("last_refill_at"),
+    enabled: boolean("enabled").default(true).notNull(),
+    rateLimitEnabled: boolean("rate_limit_enabled").default(true).notNull(),
+    rateLimitTimeWindow: integer("rate_limit_time_window"),
+    rateLimitMax: integer("rate_limit_max"),
+    requestCount: integer("request_count").default(0).notNull(),
+    remaining: integer("remaining"),
+    lastRequest: timestamp("last_request"),
+    expiresAt: timestamp("expires_at"),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at")
+      .defaultNow()
+      .$onUpdate(() => new Date())
+      .notNull(),
+    permissions: text("permissions"),
+    metadata: text("metadata"),
+  },
+  (table) => [
+    index("apikey_config_id_idx").on(table.configId),
+    index("apikey_reference_id_idx").on(table.referenceId),
+    index("apikey_key_idx").on(table.key),
+  ],
+)
+
+export const apikeyRelations = relations(apikey, ({ one }) => ({
+  user: one(user, {
+    fields: [apikey.referenceId],
+    references: [user.id],
+  }),
+}))

apps/web/lib/db/schema/community-suggestions.ts

@@ -0,0 +1,54 @@
+import {
+  index,
+  pgEnum,
+  pgTable,
+  text,
+  timestamp,
+  uniqueIndex,
+} from "drizzle-orm/pg-core"
+import { games } from "./games"
+import { user } from "./auth"
+
+export const suggestionStatusEnum = pgEnum("suggestion_status", [
+  "pending",
+  "approved",
+  "rejected",
+])
+
+export const communitySuggestions = pgTable(
+  "community_suggestions",
+  {
+    id: text("id")
+      .primaryKey()
+      .$defaultFn(() => crypto.randomUUID()),
+    gameId: text("game_id")
+      .notNull()
+      .references(() => games.id, { onDelete: "cascade" }),
+    userId: text("user_id")
+      .notNull()
+      .references(() => user.id, { onDelete: "cascade" }),
+    fieldName: text("field_name").notNull(), // e.g. "title", "description", "developer"
+    currentValue: text("current_value"), // current value (snapshot)
+    proposedValue: text("proposed_value").notNull(), // proposed new value
+    reason: text("reason"), // optional explanation
+    status: suggestionStatusEnum("status").default("pending").notNull(),
+    reviewedBy: text("reviewed_by").references(() => user.id, {
+      onDelete: "set null",
+    }),
+    reviewedAt: timestamp("reviewed_at"),
+    reviewNote: text("review_note"), // reviewer's note
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at")
+      .defaultNow()
+      .$onUpdate(() => new Date())
+      .notNull(),
+  },
+  (table) => [
+    uniqueIndex("community_suggestions_game_field_user").on(
+      table.gameId,
+      table.fieldName,
+      table.userId,
+    ),
+    index("suggestions_status_idx").on(table.status),
+  ],
+)

apps/web/lib/db/schema/entryScreenshots.ts

@@ -0,0 +1,30 @@
+import {
+  integer,
+  pgTable,
+  text,
+  timestamp,
+  index,
+} from "drizzle-orm/pg-core"
+import { performanceEntries } from "./performanceEntries"
+
+export const entryScreenshots = pgTable(
+  "entry_screenshots",
+  {
+    id: text("id")
+      .primaryKey()
+      .$defaultFn(() => crypto.randomUUID()),
+    entryId: text("entry_id")
+      .notNull()
+      .references(() => performanceEntries.id, { onDelete: "cascade" }),
+    storageKey: text("storage_key").notNull(),
+    orderIndex: integer("order_index").notNull().default(0),
+    mimeType: text("mime_type").notNull(),
+    width: integer("width").notNull(),
+    height: integer("height").notNull(),
+    originalName: text("original_name"),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+  },
+  (table) => [
+    index("entry_screenshots_entry_idx").on(table.entryId),
+  ],
+)

apps/web/lib/db/schema/gameComments.ts

@@ -0,0 +1,39 @@
+import {
+  boolean,
+  integer,
+  jsonb,
+  pgTable,
+  text,
+  timestamp,
+  index,
+} from "drizzle-orm/pg-core"
+import { games } from "./games"
+import { user } from "./auth"
+
+export const gameComments = pgTable(
+  "game_comments",
+  {
+    id: text("id")
+      .primaryKey()
+      .$defaultFn(() => crypto.randomUUID()),
+    gameId: text("game_id")
+      .notNull()
+      .references(() => games.id, { onDelete: "cascade" }),
+    userId: text("user_id")
+      .notNull()
+      .references(() => user.id, { onDelete: "cascade" }),
+    parentId: text("parent_id").references((): any => gameComments.id, { // eslint-disable-line @typescript-eslint/no-explicit-any
+      onDelete: "cascade",
+    }),
+    // Tiptap JSON document
+    content: jsonb("content").notNull().$type<Record<string, unknown>>(),
+    upvotes: integer("upvotes").default(0).notNull(),
+    isRemoved: boolean("is_removed").default(false).notNull(),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().notNull(),
+  },
+  (table) => [
+    index("comments_game_created_idx").on(table.gameId, table.createdAt),
+    index("comments_parent_idx").on(table.parentId),
+  ],
+)

apps/web/lib/db/schema/gamePlatformSupport.ts

@@ -0,0 +1,66 @@
+import {
+  boolean,
+  pgEnum,
+  pgTable,
+  text,
+  timestamp,
+  unique,
+} from "drizzle-orm/pg-core"
+import { games, playabilityStatusEnum } from "./games"
+import { hardware } from "./hardware"
+
+export const protonStatusEnum = pgEnum("proton_status", [
+  "native",
+  "proton",
+  "unsupported",
+  "unknown",
+])
+
+export const antiCheatStatusEnum = pgEnum("anti_cheat_status", [
+  "none",
+  "supported",
+  "unsupported",
+  "unknown",
+])
+
+export const gamePlatformSupport = pgTable(
+  "game_platform_support",
+  {
+    id: text("id")
+      .primaryKey()
+      .$defaultFn(() => crypto.randomUUID()),
+    gameId: text("game_id")
+      .notNull()
+      .references(() => games.id, { onDelete: "cascade" }),
+    hardwareSlug: text("hardware_slug")
+      .notNull()
+      .references(() => hardware.slug, { onDelete: "restrict" }),
+
+    // Compatibility
+    isSupported: boolean("is_supported").default(false).notNull(),
+    protonStatus: protonStatusEnum("proton_status")
+      .default("unknown")
+      .notNull(),
+
+    // Anti-cheat details
+    antiCheatRelevant: boolean("anti_cheat_relevant")
+      .default(false)
+      .notNull(),
+    antiCheatName: text("anti_cheat_name"),
+    antiCheatVersion: text("anti_cheat_version"),
+    antiCheatStatus: antiCheatStatusEnum("anti_cheat_status")
+      .default("unknown")
+      .notNull(),
+
+    // Per-device playability
+    playabilityStatus: playabilityStatusEnum("playability_status").default("unknown").notNull(),
+    playabilityOverride: boolean("playability_override").default(false).notNull(),
+    playabilityCalculatedAt: timestamp("playability_calculated_at"),
+
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().notNull(),
+  },
+  (table) => [
+    unique("game_hardware_unique").on(table.gameId, table.hardwareSlug),
+  ]
+)

apps/web/lib/db/schema/gameVersions.ts

@@ -0,0 +1,29 @@
+import {
+  boolean,
+  index,
+  pgTable,
+  text,
+  timestamp,
+  unique,
+} from "drizzle-orm/pg-core"
+import { games } from "./games"
+
+export const gameVersions = pgTable(
+  "game_versions",
+  {
+    id: text("id")
+      .primaryKey()
+      .$defaultFn(() => crypto.randomUUID()),
+    gameId: text("game_id")
+      .notNull()
+      .references(() => games.id, { onDelete: "cascade" }),
+    buildId: text("build_id"),
+    versionString: text("version_string"),
+    isLatest: boolean("is_latest").default(false).notNull(),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+  },
+  (table) => [
+    unique("game_build_unique").on(table.gameId, table.buildId),
+    index("perf_game_lookup_idx").on(table.gameId),
+  ]
+)

apps/web/lib/db/schema/games.ts

@@ -0,0 +1,105 @@
+import {
+  boolean,
+  integer,
+  jsonb,
+  pgEnum,
+  pgTable,
+  text,
+  timestamp,
+  index,
+} from "drizzle-orm/pg-core"
+
+export const gameSourceEnum = pgEnum("game_source", [
+  "steam",
+  "manual",
+  "gog",
+  "epic",
+])
+
+export const onlineMultiplayerStatusEnum = pgEnum(
+  "online_multiplayer_status",
+  ["none", "supported", "unknown"],
+)
+
+export const steamReviewSentimentEnum = pgEnum("steam_review_sentiment", [
+  "overwhelmingly_positive",
+  "very_positive",
+  "positive",
+  "mostly_positive",
+  "mixed",
+  "mostly_negative",
+  "negative",
+  "very_negative",
+  "overwhelmingly_negative",
+])
+
+export const playabilityStatusEnum = pgEnum("playability_status", [
+  "great",
+  "playable",
+  "needs_tweaks",
+  "unplayable",
+  "unknown",
+])
+
+export const games = pgTable(
+  "games",
+  {
+    id: text("id")
+      .primaryKey()
+      .$defaultFn(() => crypto.randomUUID()),
+    steamAppId: integer("steam_app_id").unique(),
+    source: gameSourceEnum("source").default("steam").notNull(),
+    slug: text("slug").unique(),
+    title: text("title").notNull(),
+    description: text("description"),
+    publisher: text("publisher"),
+    developer: text("developer"),
+    genres: jsonb("genres").$type<string[]>(),
+    headerImage: text("header_image"),
+    capsuleImage: text("capsule_image"),
+    storeUrl: text("store_url"),
+    onlineMultiplayerStatus: onlineMultiplayerStatusEnum(
+      "online_multiplayer_status",
+    )
+      .default("unknown")
+      .notNull(),
+    systemRequirements: jsonb("system_requirements").$type<{
+      minimum: string | null
+      recommended: string | null
+    }>(),
+    metacriticScore: integer("metacritic_score"),
+    metacriticUrl: text("metacritic_url"),
+    recommendationsTotal: integer("recommendations_total"),
+    steamReviewScore: integer("steam_review_score"),       // 0-100 normalized score
+    steamReviewSentiment: steamReviewSentimentEnum("steam_review_sentiment"),
+    steamReviewCount: integer("steam_review_count"),        // Total review count from Steam
+
+    // Playability (aggregate from all devices)
+    playabilityStatus: playabilityStatusEnum("playability_status").default("unknown").notNull(),
+    playabilityOverride: boolean("playability_override").default(false).notNull(), // true = manually set
+    playabilityCalculatedAt: timestamp("playability_calculated_at"),     // when auto-calculated
+    priceCurrent: integer("price_current"),
+    priceInitial: integer("price_initial"),
+    priceCurrency: text("price_currency"),
+    isFree: boolean("is_free").default(false).notNull(),
+    releaseDate: text("release_date"),
+    categories: jsonb("categories").$type<string[]>(),
+    platforms: jsonb("platforms").$type<{
+      windows: boolean
+      mac: boolean
+      linux: boolean
+    }>(),
+    lastSync: timestamp("last_sync"),
+    syncStatus: text("sync_status").default("pending"),
+    syncError: text("sync_error"),
+    syncRetryCount: integer("sync_retry_count").default(0),
+    syncNextRetry: timestamp("sync_next_retry"),
+    createdBy: text("created_by"),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().notNull(),
+  },
+  (table) => [
+    index("games_source_idx").on(table.source),
+    index("games_sync_status_idx").on(table.syncStatus, table.steamAppId),
+  ],
+)

apps/web/lib/db/schema/hardware.ts

@@ -0,0 +1,14 @@
+import { integer, pgEnum, pgTable, real, text, timestamp } from "drizzle-orm/pg-core"
+
+export const deviceTypeEnum = pgEnum("device_type", ["handheld", "console"])
+
+export const hardware = pgTable("hardware", {
+  slug: text("slug").primaryKey(),
+  name: text("name").notNull(),
+  deviceType: deviceTypeEnum("device_type").notNull(),
+  image: text("image"),
+  wattHours: real("watt_hours"),
+  tdpMax: real("tdp_max"),
+  sortOrder: integer("sort_order").default(0).notNull(),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+})

apps/web/lib/db/schema/index.ts

@@ -0,0 +1,14 @@
+// Barrel export — domain + auth schemas
+export * from "./auth"
+export * from "./games"
+export * from "./gameVersions"
+export * from "./hardware"
+export * from "./performanceEntries"
+export * from "./gamePlatformSupport"
+export * from "./gameComments"
+export * from "./savedGames"
+export * from "./reports"
+export * from "./community-suggestions"
+export * from "./saved-filters"
+export * from "./storage"
+export * from "./entryScreenshots"

apps/web/lib/db/schema/performanceEntries.ts

@@ -0,0 +1,118 @@
+import {
+  boolean,
+  integer,
+  jsonb,
+  pgEnum,
+  pgTable,
+  real,
+  text,
+  timestamp,
+  index,
+} from "drizzle-orm/pg-core"
+import { gameVersions } from "./gameVersions"
+import { hardware } from "./hardware"
+import { user } from "./auth"
+
+export const upscalerTypeEnum = pgEnum("upscaler_type", [
+  "none",
+  "fsr",
+  "dlss",
+  "xess",
+  "lsfg",
+  "other",
+])
+
+export const frameGenMethodEnum = pgEnum("frame_gen_method", [
+  "none",
+  "fsr_fg",
+  "dlss_fg",
+  "lsfg",
+  "other",
+])
+
+export type GameSettingCategory = {
+  category: string
+  settings: { title: string; value: string | number | boolean }[]
+}
+
+export const performanceEntries = pgTable(
+  "performance_entries",
+  {
+    id: text("id")
+      .primaryKey()
+      .$defaultFn(() => crypto.randomUUID()),
+    versionId: text("version_id")
+      .notNull()
+      .references(() => gameVersions.id, { onDelete: "cascade" }),
+    hardwareSlug: text("hardware_slug")
+      .notNull()
+      .references(() => hardware.slug, { onDelete: "restrict" }),
+    userId: text("user_id")
+      .notNull()
+      .references(() => user.id, { onDelete: "cascade" }),
+
+    // Performance metrics
+    fpsAvg: real("fps_avg").notNull(),
+    fpsLow: real("fps_low"),
+    fpsOnePercentLow: real("fps_one_percent_low"),
+    fpsHigh: real("fps_high"),
+
+    // Environment
+    protonVersion: text("proton_version"),
+    osVersion: text("os_version"),
+
+    // Upscaler tracking
+    upscalerType: upscalerTypeEnum("upscaler_type").default("none").notNull(),
+    upscalerVersion: text("upscaler_version"),
+    frameGenMethod: frameGenMethodEnum("frame_gen_method")
+      .default("none")
+      .notNull(),
+
+    // Load times (seconds)
+    loadTimeSsd: real("load_time_ssd"),
+    loadTimeSd: real("load_time_sd"),
+
+    // Launch options (Steam launch options string)
+    launchOptions: text("launch_options"),
+
+    // Settings & notes
+    settingsJson: jsonb("settings_json").$type<GameSettingCategory[]>(),
+    userNotes: text("user_notes"),
+
+
+    // TDP tracking (watts) — user-set TDP cap during benchmark
+    tdpWatts: real("tdp_watts"),
+
+    // YouTube video linking
+    youtubeVideoId: text("youtube_video_id"),
+
+    // Custom system flag
+    customSystem: boolean("custom_system").default(false).notNull(),
+
+    // Moderation
+    isRemoved: boolean("is_removed").default(false).notNull(),
+    isPinned: boolean("is_pinned").default(false).notNull(),
+    pinnedAt: timestamp("pinned_at"),
+    removedReason: text("removed_reason"),
+
+    // Community rating
+    upvotes: integer("upvotes").default(0).notNull(),
+    downvotes: integer("downvotes").default(0).notNull(),
+
+    // Verification (admin/mod workflow)
+    verifiedAt: timestamp("verified_at"),
+    verifiedBy: text("verified_by").references(() => user.id, {
+      onDelete: "set null",
+    }),
+
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().notNull(),
+  },
+  (table) => [
+    index("perf_hardware_upscaler_idx").on(table.hardwareSlug, table.upscalerType),
+    index("perf_version_idx").on(table.versionId),
+    index("perf_user_idx").on(table.userId),
+    index("perf_removed_created_idx").on(table.isRemoved, table.createdAt.desc()),
+    index("perf_upvotes_idx").on(table.upvotes.desc()),
+  ],
+)

apps/web/lib/db/schema/reports.ts

@@ -0,0 +1,42 @@
+import {
+  index,
+  text,
+  pgEnum,
+  pgTable,
+  timestamp,
+  uniqueIndex,
+} from "drizzle-orm/pg-core"
+import { performanceEntries } from "./performanceEntries"
+import { user } from "./auth"
+
+export const reportReasonEnum = pgEnum("report_reason", [
+  "inaccurate",
+  "spam",
+  "inappropriate",
+  "other",
+])
+
+export const reportStatusEnum = pgEnum("report_status", [
+  "open",
+  "reviewed",
+  "dismissed",
+])
+
+export const reports = pgTable("reports", {
+  id: text("id")
+    .primaryKey()
+    .$defaultFn(() => crypto.randomUUID()),
+  entryId: text("entry_id")
+    .notNull()
+    .references(() => performanceEntries.id, { onDelete: "cascade" }),
+  reporterId: text("reporter_id")
+    .notNull()
+    .references(() => user.id, { onDelete: "cascade" }),
+  reason: reportReasonEnum("reason").notNull(),
+  details: text("details"),
+  status: reportStatusEnum("status").default("open").notNull(),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+}, (table) => [
+  uniqueIndex("reports_entry_reporter_unique").on(table.entryId, table.reporterId),
+  index("reports_status_idx").on(table.status),
+])

apps/web/lib/db/schema/saved-filters.ts

@@ -0,0 +1,30 @@
+import {
+  pgTable,
+  text,
+  timestamp,
+  jsonb,
+  unique,
+} from "drizzle-orm/pg-core"
+import { user } from "./auth"
+
+export const savedFilters = pgTable(
+  "saved_filters",
+  {
+    id: text("id")
+      .primaryKey()
+      .$defaultFn(() => crypto.randomUUID()),
+    userId: text("user_id")
+      .notNull()
+      .references(() => user.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    filters: jsonb("filters").notNull(),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at")
+      .defaultNow()
+      .$onUpdate(() => new Date())
+      .notNull(),
+  },
+  (table) => [
+    unique("saved_filters_user_name").on(table.userId, table.name),
+  ],
+)

apps/web/lib/db/schema/savedGames.ts

@@ -0,0 +1,27 @@
+import {
+  pgTable,
+  text,
+  timestamp,
+  unique,
+} from "drizzle-orm/pg-core"
+import { user } from "./auth"
+import { games } from "./games"
+
+export const savedGames = pgTable(
+  "saved_games",
+  {
+    id: text("id")
+      .primaryKey()
+      .$defaultFn(() => crypto.randomUUID()),
+    userId: text("user_id")
+      .notNull()
+      .references(() => user.id, { onDelete: "cascade" }),
+    gameId: text("game_id")
+      .notNull()
+      .references(() => games.id, { onDelete: "cascade" }),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+  },
+  (table) => [
+    unique("saved_games_user_game_unique").on(table.userId, table.gameId),
+  ],
+)

apps/web/lib/db/schema/storage.ts

@@ -0,0 +1,34 @@
+import {
+  boolean,
+  integer,
+  pgTable,
+  text,
+  timestamp,
+  index,
+} from "drizzle-orm/pg-core"
+import { user } from "./auth"
+
+export const storageObjects = pgTable(
+  "storage_objects",
+  {
+    id: text("id")
+      .primaryKey()
+      .$defaultFn(() => crypto.randomUUID()),
+    key: text("key").notNull(),
+    bucket: text("bucket").notNull(),
+    size: integer("size").notNull(),
+    mimeType: text("mime_type").notNull(),
+    entityType: text("entity_type").notNull(), // "avatar" | "game_cover" | "hardware_image"
+    entityId: text("entity_id"), // user ID, game ID, or hardware slug
+    uploadedBy: text("uploaded_by")
+      .notNull()
+      .references(() => user.id, { onDelete: "cascade" }),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    lastAccessedAt: timestamp("last_accessed_at"),
+    isOrphaned: boolean("is_orphaned").default(false).notNull(),
+  },
+  (table) => [
+    index("storage_entity_idx").on(table.entityType, table.entityId),
+    index("storage_key_idx").on(table.key),
+  ],
+)

apps/web/lib/db/search.ts

@@ -0,0 +1,17 @@
+/**
+ * Normalizes a raw search query so that common word separators
+ * (spaces, hyphens, underscores, colons, dots) are treated equivalently.
+ *
+ * Replaces any sequence of separator chars with a single `%` ILIKE wildcard,
+ * then wraps the whole pattern in `%…%`.
+ *
+ * Example:
+ *   fuzzySearchTerm("counter strike")  → "%counter%strike%"
+ *   fuzzySearchTerm("counter-strike")  → "%counter%strike%"
+ *
+ * Both will match "Counter-Strike", "Counter Strike", "Counter_Strike", etc.
+ */
+export function fuzzySearchTerm(rawQuery: string): string {
+  const normalized = rawQuery.replace(/[-_\s:.]+/g, "%")
+  return `%${normalized}%`
+}

apps/web/lib/db/seed.ts

@@ -0,0 +1,51 @@
+import "dotenv/config"
+import { drizzle } from "drizzle-orm/node-postgres"
+import { Pool } from "pg"
+import { hardware } from "./schema/hardware"
+
+const pool = new Pool({
+  connectionString: process.env.DATABASE_URL,
+})
+
+const db = drizzle(pool)
+
+async function seed() {
+  // ── Hardware ──────────────────────────────────────────────────────
+  console.log("Seeding hardware table...")
+
+  const devices = [
+    {
+      slug: "steamdeck-oled",
+      name: "Steam Deck OLED",
+      deviceType: "handheld" as const,
+      sortOrder: 0,
+    },
+    {
+      slug: "steamdeck-lcd",
+      name: "Steam Deck LCD",
+      deviceType: "handheld" as const,
+      sortOrder: 1,
+    },
+    {
+      slug: "steam-machine",
+      name: "Steam Machine",
+      deviceType: "console" as const,
+      sortOrder: 2,
+    },
+  ]
+
+  for (const device of devices) {
+    await db
+      .insert(hardware)
+      .values(device)
+      .onConflictDoNothing({ target: hardware.slug })
+  }
+
+  console.log(`Seeded ${devices.length} hardware devices.`)
+  await pool.end()
+}
+
+seed().catch((err) => {
+  console.error("Seed failed:", err)
+  process.exit(1)
+})