⭐ feat(core): Implement Steam library sync with metadata extraction and image processing (#278)

## 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**
- Added AWS queue infrastructure and SQS handler for processing Steam
game libraries and images.
- Introduced event-driven handling for new credentials and game
additions, including image uploads to S3.
- Added client functions to fetch Steam user libraries, friends lists,
app info, and related images.
- Added new database columns and schema updates to track game
acquisition, playtime, and family sharing.
  - Added utility function for chunking arrays.
- Added new event notifications for library queue processing and game
creation.
  - Added new lookup functions for categories and teams by slug.
- Introduced a new Team API with endpoints to list and fetch teams by
slug.
  - Added a new Steam library page displaying game images.

- **Enhancements**
  - Improved game creation with event notifications and upsert logic.
  - Enhanced category and team retrieval with new lookup functions.
  - Renamed and refined image categories for clearer classification.
  - Expanded dependencies for image processing and AWS SDK integration.
- Improved image processing utilities with caching, ranking, and
metadata extraction.
  - Refined Steam client utilities for concurrency and error handling.

- **Bug Fixes**
- Fixed event publishing timing and removed deprecated credential
retrieval methods.

- **Chores**
- Updated infrastructure configurations with increased timeouts, memory,
and resource linking.
- Added new dependencies for image processing, caching, and AWS SDK
clients.
  - Refined internal code structure and imports for clarity.
  - Removed Steam provider and related UI components from the frontend.
- Disabled authentication providers and Steam-related routes in the
frontend.
  - Updated API fetch handler to accept environment bindings.

- **Refactor**
- Simplified query result handling and renamed functions for better
clarity.
- Removed outdated event handler in favor of consolidated event
subscriber.
- Consolidated and simplified database relationships and permission
queries.

- **Tests**
  - No explicit test changes included in this release.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

packages/core/src/library/index.ts

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { fn } from "../utils";
 import { Game } from "../game";
 import { Actor } from "../actor";
+import { createEvent } from "../event";
 import { gamesTable } from "../game/game.sql";
 import { createSelectSchema } from "drizzle-zod";
 import { steamLibraryTable } from "./library.sql";
@@ -17,31 +18,61 @@ export namespace Library {
 
     export type Info = z.infer<typeof Info>;
 
+    export const Events = {
+        Queue: createEvent(
+            "library.queue",
+            z.object({
+                appID: z.number(),
+                lastPlayed: z.date(),
+                timeAcquired: z.date(),
+                totalPlaytime: z.number(),
+                isFamilyShared: z.boolean(),
+                isFamilyShareable: z.boolean(),
+            }).array(),
+        ),
+    };
+
     export const add = fn(
-        Info,
+        Info.partial({ ownerID: true }),
         async (input) =>
             createTransaction(async (tx) => {
-                const results =
+                const ownerSteamID = input.ownerID ?? Actor.steamID()
+                const result =
                     await tx
                         .select()
                         .from(steamLibraryTable)
                         .where(
                             and(
                                 eq(steamLibraryTable.baseGameID, input.baseGameID),
-                                eq(steamLibraryTable.ownerID, input.ownerID),
+                                eq(steamLibraryTable.ownerID, ownerSteamID),
                                 isNull(steamLibraryTable.timeDeleted)
                             )
                         )
+                        .limit(1)
                         .execute()
+                        .then(rows => rows.at(0))
 
-                if (results.length > 0) return null
+                if (result) return result.baseGameID
 
                 await tx
                     .insert(steamLibraryTable)
-                    .values(input)
+                    .values({
+                        ownerID: ownerSteamID,
+                        baseGameID: input.baseGameID,
+                        lastPlayed: input.lastPlayed,
+                        totalPlaytime: input.totalPlaytime,
+                        timeAcquired: input.timeAcquired,
+                        isFamilyShared: input.isFamilyShared
+                    })
                     .onConflictDoUpdate({
                         target: [steamLibraryTable.ownerID, steamLibraryTable.baseGameID],
-                        set: { timeDeleted: null }
+                        set: {
+                            timeDeleted: null,
+                            lastPlayed: input.lastPlayed,
+                            timeAcquired: input.timeAcquired,
+                            totalPlaytime: input.totalPlaytime,
+                            isFamilyShared: input.isFamilyShared
+                        }
                     })
 
             })