⭐ feat(www): Add logic to the homepage and Steam integration (#258)

## 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**
- Upgraded API and authentication services with dynamic scaling,
enhanced load balancing, and real-time interaction endpoints.
- Introduced new commands to streamline local development and container
builds.
- Added new endpoints for retrieving Steam account information and
managing connections.
- Implemented a QR code authentication interface for Steam, enhancing
user login experiences.

- **Database Updates**
- Rolled out comprehensive schema migrations that improve data integrity
and indexing.
- Introduced new tables for managing Steam user credentials and machine
information.

- **UI Enhancements**
- Added refreshed animated assets and an improved QR code login flow for
a more engaging experience.
	- Introduced new styled components for displaying friends and games.

- **Maintenance**
- Completed extensive refactoring and configuration updates to optimize
performance and development workflows.
- Updated logging configurations and improved error handling mechanisms.
	- Streamlined resource definitions in the configuration files.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

---------

Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>

packages/core/src/steam/index.ts

@@ -0,0 +1,137 @@
+import { z } from "zod";
+import { Common } from "../common";
+import { Examples } from "../examples";
+import { createID, fn } from "../utils";
+import { useUser, useUserID } from "../actor";
+import { eq, and, isNull, sql } from "../drizzle";
+import { steamTable, AccountLimitation, LastGame } from "./steam.sql";
+import { createTransaction, useTransaction } from "../drizzle/transaction";
+
+export namespace Steam {
+    export const Info = z
+        .object({
+            id: z.string().openapi({
+                description: Common.IdDescription,
+                example: Examples.Steam.id,
+            }),
+            avatarUrl: z.string().openapi({
+                description: "The avatar url of this Steam account",
+                example: Examples.Steam.avatarUrl
+            }),
+            steamEmail: z.string().openapi({
+                description: "The email regisered with this Steam account",
+                example: Examples.Steam.steamEmail
+            }),
+            steamID: z.number().openapi({
+                description: "The Steam ID this Steam account",
+                example: Examples.Steam.steamID
+            }),
+            limitation: AccountLimitation.openapi({
+                description: " The limitations of this Steam account",
+                example: Examples.Steam.limitation
+            }),
+            lastGame: LastGame.openapi({
+                description: "The last game played on this Steam account",
+                example: Examples.Steam.lastGame
+            }),
+            userID: z.string().openapi({
+                description: "The unique id of the user who owns this steam account",
+                example: Examples.Steam.userID
+            }),
+            username: z.string().openapi({
+                description: "The unique username of this steam user",
+                example: Examples.Steam.username
+            }),
+            personaName: z.string().openapi({
+                description: "The last recorded persona name used by this account",
+                example: Examples.Steam.personaName
+            }),
+            countryCode: z.string().openapi({
+                description: "The country this account is connected from",
+                example: Examples.Steam.countryCode
+            })
+        })
+        .openapi({
+            ref: "Steam",
+            description: "Represents a steam user's information stored on Nestri",
+            example: Examples.Steam,
+        });
+
+    export type Info = z.infer<typeof Info>;
+
+    export const create = fn(
+        Info.partial({
+            id: true,
+            userID: true,
+        }),
+        (input) =>
+            createTransaction(async (tx) => {
+                const id = input.id ?? createID("steam");
+                const user = useUser()
+                await tx.insert(steamTable).values({
+                    id,
+                    lastSeen: sql`now()`,
+                    userID: input.userID ?? user.userID,
+                    countryCode: input.countryCode,
+                    username: input.username,
+                    steamID: input.steamID,
+                    lastGame: input.lastGame,
+                    limitation: input.limitation,
+                    steamEmail: input.steamEmail,
+                    avatarUrl: input.avatarUrl,
+                    personaName: input.personaName,
+                })
+                return id;
+            }),
+    );
+
+    export const fromUserID = fn(
+        z.string(),
+        (userID) =>
+            useTransaction((tx) =>
+                tx
+                    .select()
+                    .from(steamTable)
+                    .where(and(eq(steamTable.userID, userID), isNull(steamTable.timeDeleted)))
+                    .execute()
+                    .then((rows) => rows.map(serialize).at(0)),
+            ),
+    )
+
+    export const list = () =>
+        useTransaction((tx) =>
+            tx
+                .select()
+                .from(steamTable)
+                .where(and(eq(steamTable.userID, useUserID()), isNull(steamTable.timeDeleted)))
+                .execute()
+                .then((rows) => rows.map(serialize)),
+        )
+
+    /**
+     * Serializes a raw Steam table record into a standardized Info object.
+     *
+     * This function maps the fields from a database record (retrieved from the Steam table) to the
+     * corresponding properties defined in the Info schema.
+     *
+     * @param input - A raw record from the Steam table containing user information.
+     * @returns An object conforming to the Info schema.
+     */
+    export function serialize(
+        input: typeof steamTable.$inferSelect,
+    ): z.infer<typeof Info> {
+        return {
+            id: input.id,
+            userID: input.userID,
+            countryCode: input.countryCode,
+            username: input.username,
+            avatarUrl: input.avatarUrl,
+            personaName: input.personaName,
+            steamEmail: input.steamEmail,
+            steamID: input.steamID,
+            limitation: input.limitation,
+            lastGame: input.lastGame,
+        };
+    }
+
+}