⭐ feat: New account system with improved team management (#273)

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 account management with combined user and
team info.
  - Added advanced, context-aware logging utilities.
- Implemented invite code generation for teams with uniqueness
guarantees.
- Expanded example data for users, teams, subscriptions, sessions, and
games.

- **Enhancements**
- Refined user, team, member, and Steam account schemas for richer data
and validation.
  - Streamlined user creation, login acknowledgment, and error handling.
  - Improved API authentication and unified actor context management.
- Added persistent shared temporary volume support to API and auth
services.
- Enhanced Steam account management with create, update, and event
notifications.
- Refined team listing and serialization integrating Steam accounts as
members.
  - Simplified event, context, and logging systems.
- Updated API and auth middleware for better token handling and actor
provisioning.

- **Bug Fixes**
  - Fixed multiline log output to prefix each line with log level.

- **Removals**
- Removed machine and subscription management features, including
schemas and DB tables.
- Disabled machine-based authentication and removed related subject
schemas.
- Removed deprecated fields and legacy logic from member and team
management.
- Removed legacy event and error handling related to teams and members.

- **Chores**
  - Reorganized and cleaned exports across utility and API modules.
- Updated database schemas for users, teams, members, and Steam
accounts.
  - Improved internal code structure, imports, and error messaging.
- Moved logger patching to earlier initialization for consistent
logging.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

packages/core/src/steam/steam.sql.ts

@@ -1,45 +1,61 @@
 import { z } from "zod";
 import { userTable } from "../user/user.sql";
-import { id, timestamps, ulid, utc } from "../drizzle/types";
-import { index, pgTable, integer, uniqueIndex, varchar, text, json } from "drizzle-orm/pg-core";
+import { timestamps, ulid, utc } from "../drizzle/types";
+import { pgTable, varchar, text, bigint, pgEnum, json, unique } from "drizzle-orm/pg-core";
 
-export const LastGame = z.object({
-    gameID: z.number(),
-    gameName: z.string()
-});
+export const AccountStatusEnum = pgEnum("steam_account_status", ["new", "pending", "active"])
+export const StatusEnum = pgEnum("steam_status", ["online", "offline", "dnd", "playing"])
 
-export const AccountLimitation = z.object({
-    isLimited: z.boolean().nullable(),
-    isBanned: z.boolean().nullable(),
-    isLocked: z.boolean().nullable(),
-    isAllowedToInviteFriends: z.boolean().nullable(),
-});
+export const Limitations = z.object({
+    isLimited: z.boolean(),
+    isTradeBanned: z.boolean(),
+    isVacBanned: z.boolean(),
+    visibilityState: z.number(),
+    privacyState: z.enum(["public", "private"]),
+})
 
-export type LastGame = z.infer<typeof LastGame>;
-export type AccountLimitation = z.infer<typeof AccountLimitation>;
+export type Limitations = z.infer<typeof Limitations>;
 
 export const steamTable = pgTable(
-    "steam",
+    "steam_accounts",
     {
-        ...id,
         ...timestamps,
+        id: varchar("steam_id", { length: 255 })
+            .primaryKey()
+            .notNull(),
         userID: ulid("user_id")
-            .notNull()
             .references(() => userTable.id, {
                 onDelete: "cascade",
             }),
-        lastSeen: utc("last_seen").notNull(),
-        steamID: integer("steam_id").notNull(),
-        avatarUrl: text("avatar_url").notNull(),
-        lastGame: json("last_game").$type<LastGame>().notNull(),
+        status: StatusEnum("status").notNull(),
+        lastSyncedAt: utc("last_synced_at").notNull(),
+        steamMemberSince: utc("member_since").notNull(),
+        name: varchar("name", { length: 255 }).notNull(),
+        profileUrl: varchar("profileUrl", { length: 255 }),
         username: varchar("username", { length: 255 }).notNull(),
-        countryCode: varchar('country_code', { length: 2 }).notNull(),
-        steamEmail: varchar("steam_email", { length: 255 }).notNull(),
-        personaName: varchar("persona_name", { length: 255 }).notNull(),
-        limitation: json("limitation").$type<AccountLimitation>().notNull(),
+        realName: varchar("real_name", { length: 255 }).notNull(),
+        accountStatus: AccountStatusEnum("account_status").notNull(),
+        avatarHash: varchar("avatar_hash", { length: 255 }).notNull(),
+        limitations: json("limitations").$type<Limitations>().notNull(),
     },
     (table) => [
-        uniqueIndex("steam_id").on(table.steamID),
-        index("steam_user_id").on(table.userID),
-    ],
-);
+        unique("idx_steam_username").on(table.username)
+    ]
+);
+
+// export const steamCredentialsTable = pgTable(
+//     "steam_account_credentials",
+//     {
+//         ...timestamps,
+//         refreshToken: text("refresh_token")
+//             .notNull(),
+//         expiry: utc("expiry").notNull(),
+//         id: bigint("steam_id", { mode: "bigint" })
+//             .notNull()
+//             .primaryKey()
+//             .references(() => steamTable.id, {
+//                 onDelete: "cascade"
+//             }),
+//         username: varchar("username", { length: 255 }).notNull(),
+//     }
+// )