⭐ feat: Add Games (#276)

## Description
<!-- Briefly describe the purpose and scope of your changes -->


<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

- **New Features**
- Introduced comprehensive management of game libraries, including
adding, removing, and listing games in a user's Steam library.
- Added new API endpoints for retrieving detailed game information by ID
and listing all games in a user's library.
- Enabled friend-related API endpoints to list friends and fetch friend
details by SteamID.
- Added category and base game data structures with validation and
serialization for enriched game metadata.
- Introduced ownership update functionality for Steam accounts during
login.
- Added new game and category linking to support detailed game metadata
and categorization.
- Introduced member retrieval functions for enhanced team and user
management.

- **Improvements**
- Enhanced authentication to enforce team membership checks and provide
member-level access control.
- Improved Steam account ownership handling to ensure accurate user
association.
  - Added indexes to friend relationships for optimized querying.
  - Refined API routing structure with added game and friend routes.
- Improved friend listing queries for efficiency and data completeness.

- **Bug Fixes**
  - Fixed formatting issues in permissions related to Steam accounts.

- **Other**
- Refined event handling for user account refresh based on user ID
instead of email.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

packages/core/src/game/game.sql.ts

@@ -0,0 +1,33 @@
+import { timestamps } from "../drizzle/types";
+import { baseGamesTable } from "../base-game/base-game.sql";
+import { categoriesTable } from "../categories/categories.sql";
+import { index, pgTable, primaryKey, varchar } from "drizzle-orm/pg-core";
+
+export const gamesTable = pgTable(
+    'games',
+    {
+        ...timestamps,
+        baseGameID: varchar('base_game_id', { length: 255 })
+            .notNull()
+            .references(() => baseGamesTable.id,
+                { onDelete: "cascade" }
+            ),
+        categorySlug: varchar('category_slug', { length: 255 })
+            .notNull()
+            .references(() => categoriesTable.slug,
+                { onDelete: "cascade" }
+            ),
+        categoryType: varchar('category_type', { length: 255 })
+            .notNull()
+            .references(() => categoriesTable.type,
+                { onDelete: "cascade" }
+            ),
+    },
+    (table) => [
+        primaryKey({
+            columns: [table.baseGameID, table.categorySlug, table.categoryType]
+        }),
+        index("idx_games_category_slug").on(table.categorySlug),
+        index("idx_games_category_type").on(table.categoryType),
+    ]
+);

packages/core/src/game/index.ts

@@ -0,0 +1,112 @@
+import { z } from "zod";
+import { fn } from "../utils";
+import { Examples } from "../examples";
+import { BaseGame } from "../base-game";
+import { gamesTable } from "./game.sql";
+import { Categories } from "../categories";
+import { eq, and, isNull } from "drizzle-orm";
+import { createSelectSchema } from "drizzle-zod";
+import { groupBy, map, pipe, uniqueBy, values } from "remeda";
+import { baseGamesTable } from "../base-game/base-game.sql";
+import { categoriesTable } from "../categories/categories.sql";
+import { createTransaction, useTransaction } from "../drizzle/transaction";
+
+export namespace Game {
+    export const Info = z
+        .intersection(BaseGame.Info, Categories.Info)
+        .openapi({
+            ref: "Game",
+            description: "Detailed information about a game available in the Nestri library, including technical specifications, categories and metadata",
+            example: Examples.Game
+        })
+
+    export type Info = z.infer<typeof Info>
+
+    export const InputInfo = createSelectSchema(gamesTable)
+        .omit({ timeCreated: true, timeDeleted: true, timeUpdated: true })
+
+    export const create = fn(
+        InputInfo,
+        (input) =>
+            createTransaction(async (tx) => {
+                const results =
+                    await tx
+                        .select()
+                        .from(gamesTable)
+                        .where(
+                            and(
+                                eq(gamesTable.categorySlug, input.categorySlug),
+                                eq(gamesTable.categoryType, input.categoryType),
+                                eq(gamesTable.baseGameID, input.baseGameID),
+                                isNull(gamesTable.timeDeleted)
+                            )
+                        )
+                        .execute()
+
+                if (results.length > 0) return null
+
+                await tx
+                    .insert(gamesTable)
+                    .values(input)
+                    .onConflictDoUpdate({
+                        target: [gamesTable.categorySlug, gamesTable.categoryType, gamesTable.baseGameID],
+                        set: { timeDeleted: null }
+                    })
+
+                return input.baseGameID
+            })
+    )
+
+    export const fromID = fn(
+        InputInfo.shape.baseGameID,
+        (gameID) =>
+            useTransaction(async (tx) =>
+                tx
+                    .select({
+                        games: baseGamesTable,
+                        categories: categoriesTable,
+                    })
+                    .from(gamesTable)
+                    .innerJoin(baseGamesTable,
+                        eq(baseGamesTable.id, gamesTable.baseGameID)
+                    )
+                    .leftJoin(categoriesTable,
+                        and(
+                            eq(categoriesTable.slug, gamesTable.categorySlug),
+                            eq(categoriesTable.type, gamesTable.categoryType),
+                        )
+                    )
+                    .where(
+                        and(
+                            eq(gamesTable.baseGameID, gameID),
+                            isNull(gamesTable.timeDeleted)
+                        )
+                    )
+                    .execute()
+                    .then((rows) => serialize(rows).at(0))
+            )
+    )
+
+    export function serialize(
+        input: { games: typeof baseGamesTable.$inferSelect; categories: typeof categoriesTable.$inferSelect | null }[],
+    ): z.infer<typeof Info>[] {
+        return pipe(
+            input,
+            groupBy((row) => row.games.id),
+            values(),
+            map((group) => {
+                const game = BaseGame.serialize(group[0].games)
+                const cats = uniqueBy(
+                    group.map(r => r.categories).filter((c): c is typeof categoriesTable.$inferSelect => Boolean(c)),
+                    (c) => `${c.slug}:${c.type}`
+                )
+                const byType = Categories.serialize(cats)
+                return {
+                    ...game,
+                    ...byType,
+                }
+            })
+        )
+    }
+
+}